burakkose:bloghttps://www.koseburak.net/2023-01-11T16:00:00+01:00Microsoft ve Google Mülakat Tecrübem2023-01-11T16:00:00+01:002023-01-11T16:00:00+01:00Buraktag:www.koseburak.net,2023-01-11:/blog/microsoft-google-mulakat/<p>Son yazımın üzerinden çok uzun zaman geçti. Blog açmamın sebeplerinden biri, geri dönüp bakarak referans almak istediğim konular üzerine not tutmaktı ancak zaman bulamadığımdan artık bir kaç yılda bir yazar oldum.</p>
<p>Son yazımda, 2018 yılında tecrübe ettiğim <a href="https://www.koseburak.net/blog/amazon-mulakat/">Amazon mülakat sürecimi</a> paylaşmıştım. 4. yılımı tamamladıktan sonra iş değiştirme fikri ile 2022 …</p><p>Son yazımın üzerinden çok uzun zaman geçti. Blog açmamın sebeplerinden biri, geri dönüp bakarak referans almak istediğim konular üzerine not tutmaktı ancak zaman bulamadığımdan artık bir kaç yılda bir yazar oldum.</p>
<p>Son yazımda, 2018 yılında tecrübe ettiğim <a href="https://www.koseburak.net/blog/amazon-mulakat/">Amazon mülakat sürecimi</a> paylaşmıştım. 4. yılımı tamamladıktan sonra iş değiştirme fikri ile 2022 yılında firmalar ile mülakat yapmaya karar verdim. Yaklasik 5 firma ile konuşmuş olsam da en ilgi çekici olan iki tanesi hakkında bugün yazmaya karar verdim. Bu 4 yıl içerisinde Amazon mülakat sürecim hakkında çok fazla geri dönüş aldım, bunun da yardımcı olacağını umuyorum.</p>
<p>Her iki firma için de daha önceden bana ulaşmış olan IK(recruiter)'ya Linkedin üzerinden mesaj atarak başladım. Bu sefer bir ilan bulup başvurmak yerine, neler yapmak istediğimi IK'ya bildirdim. Yaklaşık bir hafta takımları ve ilgi alanlarımı konuştuktan sonra mülakat aşamasına girmeye karar verdik. Burada bahsetmem gereken sey, Microsoft ve Google süreçleri ne kadar benzer olsa da, farklılıklar var. Mesela Google alımlarını daha genel bir mülakat uzerine yaparken, Microsoft daha çok takım üzerine yapıyor.</p>
<p>Her iki firmadan telefon mülakatı yapmadan diğer aşamaya geçmelerini istedim. Google kabul ederken, Microsoft telefon mülakatının gerekli olduğunu söyledi. Süreç Amazon yazımdakine çok benzer işledi.</p>
<h4>Microsoft</h4>
<ol>
<li>Telefon mülakatı (yönetici ile teknik)</li>
<li>Teknik mülakat (kod ve sistem dizaynı)</li>
<li>Teknik mülakat (sistem dizaynı ve optimizasyonu)</li>
<li>Teknik mülakat (kod ve genel sorular)</li>
<li>Teknik mülakat (kod)</li>
</ol>
<h4>Google</h4>
<ol>
<li>Teknik mülakat (algoritma, kod)</li>
<li>Teknik mülakat (sistem dizaynı)</li>
<li>Teknik mülakat (algoritma, kod)</li>
<li>Teknik mülakat (sistem dizaynı)</li>
<li>Googleyness mülakatı (bu aşamada sizin Google için uygunluğunuzu ölçen sorular soruluyor)</li>
</ol>
<p>Tüm pozisyonlar Amerika içinde ve tamamen evden çalışma içindi. Mülakat hazırlık sürecim neredeyse 4 yıl önce yazdığım Amazon süreciyle çok benzerdi, bu sefer zamanım kısıtlı olduğu için sadece <a href="https://leetcode.com/">Leetcode</a> hesabı açtım ve <a href="https://www.amazon.com/System-Design-Interview-Insiders-Guide/dp/1736049119/ref=sr_1_3?crid=5J6N0XMPLZZ9&keywords=system+interview&qid=1673505426&sprefix=system+intervie%2Caps%2C158&sr=8-3">System Design Interview – An Insider's Guide: Volume 2</a> kitabını okudum.</p>
<p>Burada bahsetmem gereken, Microsoft mülakatı tamamen takıma bağlıyken, Google genel mülakat yaptığı için genelde süreç herkes için genel oluyor. Google'da sorulan soruları internette bulamadım, dolayısıyla temel konulara hakim olmanız önemli. Microsoft'da karar takım içerisinde alınırken, Google'da birden fazla komite bulunuyor. Once sizi <code>hiring committee</code> onaylıyor, bundan sonra <code>team matching</code> yani sizinle ilgilenen takımlar iletişime geçiyor. Bu süreç bazı kisiler için çok uzayabiliyor. Daha sonrasında maaş ve teklif ile size dönüyorlar. Her zaman olduğu gibi, birden fazla teklifinizin olması bu aşamada pazarlık sürecini etkiliyor.</p>
<p>Her iki firmadan teklif aldıktan sonra, Microsoft ile devam etme kararı aldım. Beni yakından tanıyanlar az çok bilecektir, 10 yıldan fazladır Linux kullanıcısıyım. Amazon'da çalışanlara Linux bilgisayar(genelde Mac) verilebilmesi için komünite içerisinde az çaba sarf etmemiştim, ancak Microsoft'da böyle bir durumum yok ve şuan taze bir Windows kullanıcısıyım :)</p>
<p>Umarım yazı ileride Google ve Microsoft gibi firmalar ile mülakatı olanlar için faydalı olmuştur. Daha detaylı bir çalışma aşaması için <a href="https://www.koseburak.net/blog/amazon-mulakat/">Amazon mülakat süreci</a> yazıma da bakmanızı öneririm.</p>
<p>Burak</p>A'dan Z'ye Amazon Mülakat Tecrübem2018-04-29T16:00:00+02:002018-04-29T16:00:00+02:00Buraktag:www.koseburak.net,2018-04-29:/blog/amazon-mulakat/<p>Nisan ayında Amazon’un Dublin ofisinde mülakat yaptıktan ve teklif aldıktan sonra, yaşadığım tecrübeyi paylaşma kararı verdim.
<center>
<img alt="amazon-logo-300px" src="https://upload.wikimedia.org/wikipedia/commons/a/a9/Amazon_logo.svg">
</center>
Bir gün merakımdan Amazon’nun kariyer <a href="https://www.amazon.jobs/">sayfasında</a> açık olan ilanlara bakıyordum. O gün gözüme bir pozisyon takıldı, iş ilanında güvenlik alanındaki verilerin analizi için uğraşacak, Scala ve Spark bilen kişi arıyorlardı. Çok sıradan …</p><p>Nisan ayında Amazon’un Dublin ofisinde mülakat yaptıktan ve teklif aldıktan sonra, yaşadığım tecrübeyi paylaşma kararı verdim.
<center>
<img alt="amazon-logo-300px" src="https://upload.wikimedia.org/wikipedia/commons/a/a9/Amazon_logo.svg">
</center>
Bir gün merakımdan Amazon’nun kariyer <a href="https://www.amazon.jobs/">sayfasında</a> açık olan ilanlara bakıyordum. O gün gözüme bir pozisyon takıldı, iş ilanında güvenlik alanındaki verilerin analizi için uğraşacak, Scala ve Spark bilen kişi arıyorlardı. Çok sıradan bir başvuru ile(sadece cv) başvurumu tamamladım. Yaklaşık 1 hafta sonra Amazon’un İK’sı tarafından mülakat daveti aldım ve zorlu süreç böylece başlamış oldu.</p>
<p>İlk mülakat İK ile telefon üzerinde oldu. Teknik hiç bir soru olmadan sadece beni tanımaya yönelik soruları cevapladım.</p>
<p>Aradan iki gün geçtikten sonra ikinci mülakat daveti ile geldiler. Bu mülakat da telefon üzerinde olacaktı ancak bu sefer tamamen teknik mülakattı. Mülakat yaptığım kişi Madrid ofisinde çalışıyordu. Yaklaşık 1 saat sürdü. Normal soruların yanında kısa cevaplı teknik sorular vardı. Kapanış ise yaklaşık 25 dk süren bir problemin, online bir notepad üzerinde çözümü ile bitti. Ne sorulduğunu paylaşmam doğru olmayacaktır ancak yazının ileriki aşamalarında bununla ilgili bilgiler veriyor olacağım.</p>
<p>Aradan tekrar iki gün geçtikten sonra üçüncü telefon mülakatı için davet geldi. Bu sefer ki mülakatım, Seattle ofisinden biri ile oldu. Tekrar kısa cevaplı soruların ardından, iki kodlamalı problem çözdüm. Bunlardan biri normal algoritma sorusu, ikincisi ise Spark’da bir problemin çözümüydü. Sizden tamamen çalışacak çözüm bekleniyor. Dolayısı ile eğer statically typed bir dil kullanıyorsanız compile olabilecek şekilde, dynamically typed ise direkt hatasız yorumlanacak şekilde yazılmalı.</p>
<p>İki veya üç gün sonra, yeni bir mülakat daveti aldım. Asıl süreç bundan sonra başlıyor, çünkü bu sefer mülakat İrlanda ofisinde olacaktı. Burası biraz stresli bir süreç. Ben Amsterdam’da çalıştığım için Schengen ülkelerine vize muafiyetim var ancak İrlanda Schengen üyesi bir ülke değil. Dolayısı ile bir ton doküman ile Den Haag’da bulunan İrlanda elçiliğine başvurumu yaptım. Vizenin elime ulaşması tam olarak üç hafta sürdü.</p>
<p>Vize onaylandıktan sonra, tüm masraflar Amazon tarafından karşılanmak üzere Amsterdam’dan Dublin’e uçuşumu gerçekleştirdim. </p>
<p>Tüm yaşadıklarımı anlatmadan önce mülakat günü hakkında kısa bir bilgi vereceğim. Benim mülakatım saat 11:00’da başladı ve 17:30’da son buldu. Bu uzun süreçte yaklaşık 9 kişi ile mülakat yaptım. Her bir mülakat oturumuna iki kişi dahil oldu ve biri sürekli not alıyordu.</p>
<p>Şimdi kısaca yaşanılanları anlatayım. </p>
<ol>
<li>
<p>Oturum:
Bu oturumda başka bir takımınin lideri ile konuştum. Kısaca gün hakkında bilgi ve bir kaç tüyo verdikten sonra, <code>Amazon Liderlik Prensipleri</code> ile ilgili sorular sordu. Bunun ne demek olduğunu ileriki aşamada anlatıyor olacağım. Bu aşamada hiç teknik bir soru yoktu.</p>
</li>
<li>
<p>Oturum:
Bu oturuma, başvurduğum takımda çalışan iki kişi girdi. Normal sorular ile başladıktan sonra, iki adet soru sordular. İki soru da tamamen çalışacak şekilde, beyaz tahtada çözüldü. Açıkçası günün en iyi oturumlarından biri buydu. Beklenilenden çok daha iyi bir çözüm sunmuştum. Burada önemli olan, yazdığınız kodun çalışacak olması, edge case dediğimiz durumlar karşısında güvenilir olması ve algoritma analizinin doğru sunulup, tartışılması.</p>
</li>
<li>
<p>Oturum:
Aslında bu aşama bir mülakat değildi. Amazon içerisinden tamamen rastgele biri bana öğlen yemeği için eşlik etti. Yemek sırasında istediğiniz soruyu sorabilirsiniz. Biz daha çok machine learning, recommender systems hakkında konuştuk. Kendisi bana aynı zamanda, daha önceki mülakatlarımda alınan notları okuduğunu ve her şeyin harika gittiğini de söyledi. Açıkçası bu baya motive edici oldu.</p>
</li>
<li>
<p>Oturum:
Bu oturuma da iki kişi dahil oldu. Aynı öncekilerde olduğu gibi, normal sorular ile başladık ve iki adet beyaz tahta problemi ile devam ettik. Bu arada, istediğiniz programlama dilini kullanabilirsiniz. Ben hep Scala kullandım. Açıkçası sorulardan biri baya zorlayıcıydı. Biraz zaman harcadıktan sonra güzel bir algoritma karmaşıklığında çözüm sundum. Dolayısı ile bu aşama da başarılıydı.</p>
</li>
<li>
<p>Oturum:
Bu oturum, benim ileride çalışacağım takımın lideri ile oldu. Açıkçası buradaki soru bu zamana kadar gördüğüm en zor sorulardan biriydi. Önce normal sorular ile başladıktan sonra, problemi beyaz tahtada anlattı. Problemin anlatılması bile baya uzun sürdü. Uzun bir süre sesli düşünme sonunda aklıma gelen çözümü paylaştım. Hoşuna gittiğini söyledikten sonra tahtada kodlamaya başladım. Çözüm doğru olsa da algoritma karmaşıklığı yüksekti. Bir kaç optimizasyon sonrası çözüme ulaştım. Çözümün istediği gibi olduğunu belirtti.</p>
</li>
<li>
<p>Oturum:
Açıkçası bu aşamada artık çok yorgun hissediyordum. Şansıma mülakat Amerika’dan biri ile oldu. Dolayısı ile bir kodlama problemi yoktu. Bu bir sistem dizayn oturumuydu. Problemi anlattıktan sonra dizayn etmemi istedi. Burada önemli nokta, önce problemi anlamak için sorular sormalısınız. Ortaya bir çözüm sundum, daha sonrasında sistemi ölçeklemem istendi. Sonuç olarak bu aşama da güzel geçmişti.</p>
</li>
</ol>
<p>Kısacası tüm günüm bu şekilde geçtikten sonra ofisten ayrılıp şehrin tadını çıkardım. Sonuç ise tamamen olumluydu. Aradan bir iki güç geçtikten sonra teklifi aldım ve kabul ettim.</p>
<p>Biraz da önerilerimden bahsedelim. Amazon, Google ve Apple gibi firmaların mülakatlarına hazırlanmak emek gerektiriyor. Pozisyona bağlı olsada bana göre en az iki hafta gerekiyor. Ayrıca genel mülakat tecrübesine sahip olmak çok yardımcı olacaktır. Peki ben neler yaptım?</p>
<p><a href="https://www.quora.com/How-can-I-crack-an-interview-at-Amazon">How can I crack an interview at Amazon?</a></p>
<p><a href="https://www.quora.com/How-should-I-prepare-for-my-Amazon-SDE-interview-in-2-months">How should I prepare for my Amazon SDE interview in 2 months?</a></p>
<p>Açıkçası, temel konularda zorlanmadım. Çünkü her zaman algoritmalar ve veri yapılarına ilgi duymuşumdur. Bu aşamada en büyük yardımcınız <code>GeeksforGeeks</code> olacaktır. Eğer temelinizde sıkıntı varsa yavaş yavaş çalışmanızı öneririm. Bu konuda bir diğer önerim ise, soruları çözdükçe <a href="https://github.com/">Github</a>'da oluşturduğunuz depoda tutun. Tekrar etme aşaması daha kolay olacaktır.</p>
<p><a href="https://www.geeksforgeeks.org/">GeeksforGeeks | A computer science portal for geeks</a></p>
<p><a href="https://leetcode.com/">LeetCode | Online Programming Learning Platform</a></p>
<p><a href="https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/098478280X">Cracking the Coding Interview</a></p>
<p>İkinci önerim ise sistem dizayn kısmında bilgili olmanız. Açıkçası bu aşama da bana fazla zaman kaybettirmedi. Şu anki işim gereği, sürekli ölçeklenebilirlik ile uğraşmaktayım. Aşağıdaki kaynaklar fazlası ile yardımcı olacaktır.</p>
<p><a href="https://github.com/donnemartin/system-design-primer">The System Design Primer</a></p>
<p><a href="https://www.educative.io/collection/5668639101419520/5649050225344512">Grokking the System Design Interview</a></p>
<p>Son olarak <code>Amazon Liderlik Prensipleri</code>. Nedir bu? <a href="https://www.amazon.jobs/principles">Şuradan</a> gerekli tüm bilgiyi edinebilirsiniz. Tüm oturumlarda bunlar ile ilgili sorular geliyor ve Amazon için bu çok önemli. Çok iyi teknik bilginiz olsa dahi, eğer bu maddeleri taşımıyorsanız, işi almanız çok zor olacaktır. </p>
<p><strong>Örnek bir soru:</strong> “Bana yöneticin ile yaşadığın bir zıtlık anını anlat.”</p>
<p>Daha fazla bilgi için, bu <a href="https://docs.google.com/spreadsheets/d/1D7xwpTrutYB4mRd7FJL0kb3Yd042vqffy6E_N500Pkg/edit#gid=1513231308">kaynaga</a> bakabilirsiniz.</p>
<p>Umarım yazı ileride Amazon ile mülalatı olanlara için faydalı olmuştur.</p>
<p>Burak KOSE</p>Type class nedir? - FP2017-06-10T19:00:00+02:002017-06-10T19:00:00+02:00Buraktag:www.koseburak.net,2017-06-10:/blog/typeclass/<p>Yazıya başlamadan önce belirtmem gerekir ki örnekleri Scala üzerinden verdiğim için Scala ve temel düzeyde implicit kavramını bildiğinizi varsaymaktayım.</p>
<p>Type class'ı basitçe anlatmak gerekirse, uygulamamız sahip olmak istediğimiz bazı işlevsellikleri sağlayan bir arayüzdür. Scala'da çoğunlukla trait ile birlikte en az bir type parametresi ile tanımlanır. En önemli özelliklerinden biri <code>ad-hoc …</code></p><p>Yazıya başlamadan önce belirtmem gerekir ki örnekleri Scala üzerinden verdiğim için Scala ve temel düzeyde implicit kavramını bildiğinizi varsaymaktayım.</p>
<p>Type class'ı basitçe anlatmak gerekirse, uygulamamız sahip olmak istediğimiz bazı işlevsellikleri sağlayan bir arayüzdür. Scala'da çoğunlukla trait ile birlikte en az bir type parametresi ile tanımlanır. En önemli özelliklerinden biri <code>ad-hoc polymorphism</code> sağlamasıdır. Örnek vermeden önce <code>parametric polymorphism</code> ve <code>ad-hoc polymorphism</code> terimlerine biraz değinmek isterim.</p>
<p>Parametric polymorphism kısaca, implementasyonu tüm tipler için aynı olan kod parçasıdır. Scala standard kütüphanesinden örnek vermek istersek, <code>head</code> methodunu örnek verebiliriz. Düşünün elimizde bir string listesi ve bir inteğer listesi bulunmakta.</p>
<div class="highlight"><pre><span></span><code>val sList = List("a", "b", "c")
val iList = List(1, 2, 3)
sList.head
// res0: String = a
iList.head
// res1: Int = 1
</code></pre></div>
<p>Yapılan iş, elimizde olan listenin ilk elemanın döndürmektir. Değişen tek şey sahip olduğumuz type.</p>
<p>Ad-hoc polymorphism ise biraz daha farklı ve kısaca method overloading olarak anlatabilirz. Sahip olduğumuz methodun işlevi değişmektedir. Type class kısaca bu özelliği bize sağlamaktadır. Örnek vermek için ilk olarak ADT tanımlamalarından başlayalım.</p>
<div class="highlight"><pre><span></span><code><span class="n">sealed</span><span class="w"> </span><span class="n">trait</span><span class="w"> </span><span class="n">Shape</span>
<span class="n">case</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="n">Rectangle</span><span class="p">(</span><span class="n">width</span><span class="p">:</span><span class="w"> </span><span class="n">Double</span><span class="p">,</span><span class="w"> </span><span class="n">height</span><span class="p">:</span><span class="w"> </span><span class="n">Double</span><span class="p">)</span><span class="w"> </span><span class="k">extends</span><span class="w"> </span><span class="n">Shape</span>
<span class="n">case</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="n">Circle</span><span class="p">(</span><span class="n">radius</span><span class="p">:</span><span class="w"> </span><span class="n">Double</span><span class="p">)</span><span class="w"> </span><span class="k">extends</span><span class="w"> </span><span class="n">Shape</span>
</code></pre></div>
<p>Devamında Encoder type class'ımızı tanımlayalım.</p>
<div class="highlight"><pre><span></span><code><span class="n">trait</span><span class="w"> </span><span class="n">Encoder</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">encode</span><span class="p">(</span><span class="k">value</span><span class="err">:</span><span class="w"> </span><span class="n">A</span><span class="p">)</span><span class="err">:</span><span class="w"> </span><span class="n">List</span><span class="o">[</span><span class="n">String</span><span class="o">]</span>
<span class="err">}</span>
</code></pre></div>
<p>Genelde aşağıdaki gibi bir companion object tanımlaması güzel bir pratiktir.</p>
<div class="highlight"><pre><span></span><code><span class="k">object</span><span class="w"> </span><span class="n">Encoder</span><span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="ss">"Summoner"</span><span class="w"> </span><span class="k">method</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">apply</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="p">(</span><span class="n">implicit</span><span class="w"> </span><span class="nl">enc</span><span class="p">:</span><span class="w"> </span><span class="n">Encoder</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="p">)</span><span class="err">:</span><span class="w"> </span><span class="n">Encoder</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">enc</span>
<span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="ss">"Constructor"</span><span class="w"> </span><span class="k">method</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">instance</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="p">(</span><span class="nl">func</span><span class="p">:</span><span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="o">=></span><span class="w"> </span><span class="n">List</span><span class="o">[</span><span class="n">String</span><span class="o">]</span><span class="p">)</span><span class="err">:</span><span class="w"> </span><span class="n">Encoder</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Encoder</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">encode</span><span class="p">(</span><span class="k">value</span><span class="err">:</span><span class="w"> </span><span class="n">A</span><span class="p">)</span><span class="err">:</span><span class="w"> </span><span class="n">List</span><span class="o">[</span><span class="n">String</span><span class="o">]</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="n">func</span><span class="p">(</span><span class="k">value</span><span class="p">)</span>
<span class="w"> </span><span class="err">}</span>
<span class="err">}</span>
</code></pre></div>
<p>Kısaca yapmak istediğimiz, elimizde olan adt'leri string listesi şeklinde tanımlamak. Bunun için;</p>
<div class="highlight"><pre><span></span><code><span class="n">implicit</span><span class="w"> </span><span class="n">val</span><span class="w"> </span><span class="n">rectangleEncoder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Encoder</span><span class="p">.</span><span class="n">instance</span><span class="o">[</span><span class="n">Rectangle</span><span class="o">]</span><span class="w"> </span><span class="err">{</span><span class="w"> </span><span class="n">rec</span><span class="w"> </span><span class="o">=></span>
<span class="w"> </span><span class="n">List</span><span class="p">(</span>
<span class="w"> </span><span class="n">rec</span><span class="p">.</span><span class="n">width</span><span class="p">.</span><span class="n">toString</span><span class="p">,</span>
<span class="w"> </span><span class="n">rec</span><span class="p">.</span><span class="n">height</span><span class="p">.</span><span class="n">toString</span>
<span class="w"> </span><span class="p">)</span>
<span class="err">}</span>
<span class="n">implicit</span><span class="w"> </span><span class="n">val</span><span class="w"> </span><span class="n">circleEncoder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Encoder</span><span class="p">.</span><span class="n">instance</span><span class="o">[</span><span class="n">Circle</span><span class="o">]</span><span class="w"> </span><span class="err">{</span><span class="w"> </span><span class="n">cir</span><span class="w"> </span><span class="o">=></span>
<span class="w"> </span><span class="n">List</span><span class="p">(</span><span class="n">cir</span><span class="p">.</span><span class="n">radius</span><span class="p">.</span><span class="n">toString</span><span class="p">)</span>
<span class="err">}</span>
</code></pre></div>
<p>tanımlamalarını yapalım. Şimdi gerçek işi yapacak olan kodu yazalım.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="k">print</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="p">(</span><span class="k">value</span><span class="err">:</span><span class="w"> </span><span class="n">Seq</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="p">)(</span><span class="n">implicit</span><span class="w"> </span><span class="nl">encoder</span><span class="p">:</span><span class="w"> </span><span class="n">Encoder</span><span class="o">[</span><span class="n">A</span><span class="o">]</span><span class="p">)</span><span class="err">:</span><span class="w"> </span><span class="n">Unit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="n">println</span><span class="p">(</span>
<span class="w"> </span><span class="k">value</span>
<span class="w"> </span><span class="p">.</span><span class="k">map</span><span class="p">(</span><span class="k">value</span><span class="w"> </span><span class="o">=></span><span class="w"> </span><span class="n">encoder</span><span class="p">.</span><span class="n">encode</span><span class="p">(</span><span class="k">value</span><span class="p">).</span><span class="n">mkString</span><span class="p">(</span><span class="ss">"|"</span><span class="p">))</span>
<span class="w"> </span><span class="p">.</span><span class="n">mkString</span><span class="p">(</span><span class="ss">"{\n"</span><span class="p">,</span><span class="w"> </span><span class="ss">"\n"</span><span class="p">,</span><span class="w"> </span><span class="ss">"\n}"</span><span class="p">))</span>
<span class="err">}</span>
</code></pre></div>
<p>Kod oldukça basit. Parametre olarak Seq[A] alıyor ve implicit olarak bu type için tanımlanmış encoder'a bakıyor ve encode edilmiş stringi ekrana yazdırıyor.</p>
<div class="highlight"><pre><span></span><code>val circles = List(
Circle(5),
Circle(6)
)
print(circles)
// {
// 5.0
// 6.0
// }
val rectangles = List(
Rectangle(1, 2),
Rectangle(2, 3)
)
print(rectangles)
// {
// 1.0|2.0
// 2.0|3.0
// }
</code></pre></div>
<p>Kodun üzerine biraz daha düşünelim. Mesela şunu denersek;</p>
<div class="highlight"><pre><span></span><code>val<span class="w"> </span>shapes:<span class="w"> </span>Seq[Shape]<span class="w"> </span>=<span class="w"> </span>List(
<span class="w"> </span>Circle(5),
<span class="w"> </span>Circle(6),
<span class="w"> </span>Rectangle(1,<span class="w"> </span>2),
<span class="w"> </span>Rectangle(2,<span class="w"> </span>3)
)
print(shapes)
</code></pre></div>
<p>Şu hatayı verecektir.</p>
<blockquote>
<p>could not find implicit value for parameter encoder: Encoder[Shape]</p>
</blockquote>
<p>Encoder type class'ı sadece shape için olduğundan kodu geliştirmek için şunu yazabiliriz;</p>
<div class="highlight"><pre><span></span><code><span class="n">implicit</span><span class="w"> </span><span class="n">val</span><span class="w"> </span><span class="n">shapeEncoder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Encoder</span><span class="p">.</span><span class="n">instance</span><span class="o">[</span><span class="n">Shape</span><span class="o">]</span><span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="k">case</span><span class="w"> </span><span class="nl">rec</span><span class="p">:</span><span class="w"> </span><span class="n">Rectangle</span><span class="w"> </span><span class="o">=></span>
<span class="w"> </span><span class="n">List</span><span class="p">(</span>
<span class="w"> </span><span class="n">rec</span><span class="p">.</span><span class="n">width</span><span class="p">.</span><span class="n">toString</span><span class="p">,</span>
<span class="w"> </span><span class="n">rec</span><span class="p">.</span><span class="n">height</span><span class="p">.</span><span class="n">toString</span>
<span class="w"> </span><span class="p">)</span>
<span class="w"> </span><span class="k">case</span><span class="w"> </span><span class="nl">circle</span><span class="p">:</span><span class="w"> </span><span class="n">Circle</span><span class="w"> </span><span class="o">=></span><span class="w"> </span><span class="n">List</span><span class="p">(</span><span class="n">circle</span><span class="p">.</span><span class="n">radius</span><span class="p">.</span><span class="n">toString</span><span class="p">)</span>
<span class="err">}</span>
</code></pre></div>
<p>ve çıktı.</p>
<div class="highlight"><pre><span></span><code>{
5.0
6.0
1.0|2.0
2.0|3.0
}
</code></pre></div>
<p>Burak KOSE</p>Algebraic Data Types nedir? - FP2017-06-09T19:00:00+02:002017-06-09T19:00:00+02:00Buraktag:www.koseburak.net,2017-06-09:/blog/algebraic-data-types/<p>İsmi bu kadar karmaşık olup da arkasındaki fikir bu kadar basit olan bir yapı olduğunu sanmıyorum. Olay tamamen veriyi modellemektir, davranışlar ile ilgilenilmez. Veri modellenirken mantıksal ve(and) ile veya(or) işleminden yararlanılır. Kısaca örnek vermek gerekirse:</p>
<div class="highlight"><pre><span></span><code><span class="n">sealed</span><span class="w"> </span><span class="n">trait</span><span class="w"> </span><span class="err">Ş</span><span class="n">ekil</span>
<span class="n">case</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="err">Ç</span><span class="n">ember</span><span class="p">(</span><span class="n">v</span><span class="p">:</span><span class="w"> </span><span class="n">Double</span><span class="p">)</span><span class="w"> </span><span class="k">extends</span><span class="w"> </span><span class="err">Ş</span><span class="n">ekil …</span></code></pre></div><p>İsmi bu kadar karmaşık olup da arkasındaki fikir bu kadar basit olan bir yapı olduğunu sanmıyorum. Olay tamamen veriyi modellemektir, davranışlar ile ilgilenilmez. Veri modellenirken mantıksal ve(and) ile veya(or) işleminden yararlanılır. Kısaca örnek vermek gerekirse:</p>
<div class="highlight"><pre><span></span><code><span class="n">sealed</span><span class="w"> </span><span class="n">trait</span><span class="w"> </span><span class="err">Ş</span><span class="n">ekil</span>
<span class="n">case</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="err">Ç</span><span class="n">ember</span><span class="p">(</span><span class="n">v</span><span class="p">:</span><span class="w"> </span><span class="n">Double</span><span class="p">)</span><span class="w"> </span><span class="k">extends</span><span class="w"> </span><span class="err">Ş</span><span class="n">ekil</span>
<span class="n">case</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="err">Üç</span><span class="n">gen</span><span class="p">(</span><span class="n">v1</span><span class="p">:</span><span class="w"> </span><span class="n">Int</span><span class="p">,</span><span class="w"> </span><span class="n">v2</span><span class="p">:</span><span class="w"> </span><span class="n">Int</span><span class="p">)</span><span class="w"> </span><span class="k">extends</span><span class="w"> </span><span class="err">Ş</span><span class="n">ekil</span>
</code></pre></div>
<p>Örneği anlayabileceğimiz sözlü ifadeye döktüğümüzde ise;</p>
<blockquote>
<p>Şekil bir üçgen <code>veya</code> çemberdir</p>
<p>Üçgen v1 <code>ve</code> v2 olmak üzere iki inteğer sahibidir</p>
<p>Çember v olmak üzere bir inteğer sahibidir</p>
</blockquote>
<p>Buradan anlaşılabileceği gibi şekil bir <code>coproduct</code>, üçgen ve çember ise <code>product</code>'dır. Sahip olduğumuz coproduct ve product ifadelerini daha farklı olarak şu şekilde de tanımlayabiliriz.</p>
<div class="highlight"><pre><span></span><code>type<span class="w"> </span>Ucgen<span class="w"> </span>=<span class="w"> </span>(Int,<span class="w"> </span>Int)
type<span class="w"> </span>Cember<span class="w"> </span>=<span class="w"> </span>Double
type<span class="w"> </span>Sekil<span class="w"> </span>=<span class="w"> </span>Either[Ucgen,<span class="w"> </span>Cember]
val<span class="w"> </span>rect:<span class="w"> </span>Sekil<span class="w"> </span>=<span class="w"> </span>Left((3,<span class="w"> </span>4))
val<span class="w"> </span>circ:<span class="w"> </span>Sekil<span class="w"> </span>=<span class="w"> </span>Right(1.0)
</code></pre></div>
<p>Scala standard kütüphanesinden örnek vermek istersek:</p>
<p>
<div class="justtable">
<table>
<thead>
<tr>
<th>Type</th>
<th> Value Constructors</th>
</tr>
</thead>
<tbody>
<tr>
<td>Option</td>
<td> None ve Some</td>
</tr>
<tr>
<td>Either</td>
<td> Left ve Right</td>
</tr>
<tr>
<td>Try</td>
<td> Success ve Failure</td>
</tr>
<tr>
<td>List</td>
<td> Nil ve ::</td>
</tr>
</tbody>
</table>
</div></p>
<p>Burak KOSE</p>Apache Spark - Part 2 : Resilient Distributed Datasets2015-10-23T23:00:00+02:002015-10-23T23:00:00+02:00Buraktag:www.koseburak.net,2015-10-23:/blog/apache-spark-part2/<p><a href="https://www.koseburak.net/blog/apache-spark-part1/">Bir önceki yazımda</a> Apache Spark kurlumunu ve basit bir kaç örneği incelemiştik. Bu yazıda RDD("resilient distributed dataset) yani esnek dağıtık veri kümelerini inceliyor olacağız.</p>
<p>RDD'ler basitçe değişmez(immutable) dağıtık obje koleksiyonlarıdır ve her biri farklı düğümlerde hesaplanmak üzere çeşitli parçalara bölünmüş şekildedir. Python, Scala veya Java'nın sahip olduğu tüm …</p><p><a href="https://www.koseburak.net/blog/apache-spark-part1/">Bir önceki yazımda</a> Apache Spark kurlumunu ve basit bir kaç örneği incelemiştik. Bu yazıda RDD("resilient distributed dataset) yani esnek dağıtık veri kümelerini inceliyor olacağız.</p>
<p>RDD'ler basitçe değişmez(immutable) dağıtık obje koleksiyonlarıdır ve her biri farklı düğümlerde hesaplanmak üzere çeşitli parçalara bölünmüş şekildedir. Python, Scala veya Java'nın sahip olduğu tüm obje türlerini içerebilmekle beraber sizin de tanımladığınız sınıfları içerebilir.</p>
<p><a href="https://www.koseburak.net/blog/apache-spark-part1/">Önceki yazımda</a>; örneğimizde <code>lines = sc.textFile("README.md")</code> gibi bir kod kullandık. Bu kullanım ile aslında Python'da bir string RDD'si yaratmış olduk.</p>
<p>Oluşturulan bir RDD yaratıldıktan sonra iki çeşit operasyonla kullanılabilir(bkz:transformations veya actions). Transformation işlemleri ile bir önceki RDD'den yeni bir RDD yaratılmasını sağlar.Örneğin bir önceki yazıda kullandığımız örneğe bakalım.</p>
<p><code>pythonLines = lines.filter(lambda line: "Python" in line)</code></p>
<p>Burada bir önceki RDD'yi(<strong>'lines'</strong>) kullanarak yeni bir RDD(<strong>'pythonLines'</strong>) oluşturuyoruz.</p>
<p>Action ise sahip olduğumuz RDD üzerinde hesaplama türü işlemler yapmaktır. Örneğin;</p>
<p><code>pythonLines.first()</code></p>
<h4>Cache veya Persist</h4>
<p>Eğer elinizdeki bir RDD'yi birçok kez kullanacaksak ve performansdan kazanmak istiyorsak, Spark'a bunu <code>RDD.persist()</code> şeklinde bildirerek, memory'i kullanarak daha fazla performans elde edebilirsiniz(cache(), persist() ile aynı işlevi görür).Yazının devamında bu konuyu işliyor olacağız fakat kullanımı aşağıdaki gibidir.</p>
<p><code>pythonLines.persist</code></p>
<p>Özetlemek gerekirse her Spark uygulaması aşağıdaki gibi bir yol izler.</p>
<ol>
<li>Elindeki verilerden RDD'ler oluştur.</li>
<li>Yeni RDD'ler elde et.(Transformation aşaması)</li>
<li>Eğer birden fazla işlem yapacaksan Spark'a persist işlemini bildir.</li>
<li>Elindeki veriyi işle.(Action aşaması)</li>
</ol>
<h3>RDD oluşturmak</h3>
<h4>1.Var olan bir koleksiyondan</h4>
<p><code>lines = sc.parallelize(["burak", "kose", "arch" , "linux"])</code></p>
<p>Protatip ve test işlemleri yaparken uygun olan bir yöntemdir fakat gerçek zamanlı uyglamalarda çok da kullanışlı değildir, çünkü tek bir makinenin hafızasında büyük bir veri olması gerekmektedir ve dolayısı ile çoğu zaman böyle bir kaynak mümkün değildir.</p>
<h4>2.Harici depolamadan</h4>
<p><code>data = sc.textFile("file-path")</code> şeklinde kullanımdır.</p>
<h3>Dönüşümler(Transformations)</h3>
<p>Yürütülen her bir transformation işlemi gerçekten bir action ile karşılaşana kadar gerçekleştirilmez.Buna <code>"Lazy Evaluation"</code> denir. "Lazy Evaluation" terimine daha önce foksiyonel bir programlama dili uğraşanlar aşinadır fakat terimi kısaca açıklamak gerekirse bir işlemin mecbur kalınana kadar yürütülmediği bir yaklaşımdır.</p>
<p>Bir örnek gösterelim, elimizde bir log dosyası olsun ve biz içerisinde "error" geçen logları elde etmek isteyelim.Yapmamız gereken</p>
<p><em>Örnek : filter()</em></p>
<div class="highlight"><pre><span></span><code>input = sc.textFile("log.txt")
error = input.filter(lambda x: "error" in x)
</code></pre></div>
<p>şeklinde olacaktır.<strong>error</strong>'un yeni bir RDD olduğuna dikkat edin.</p>
<p><em>Örnek : union()</em></p>
<div class="highlight"><pre><span></span><code>errorsRDD = inputRDD.filter(lambda x: "error" in x)
warningsRDD = inputRDD.filter(lambda x: "warning" in x)
badLinesRDD = errorsRDD.union(warningsRDD)
</code></pre></div>
<p>Yapılan işleri aşağıdaki gibi bir görsel ile özetleyebiliriz.</p>
<p><center><img alt="1" src="/images/apache_spark/2/1.png"></center></p>
<p>İki çok genel transformation işlemi vardır, <strong>map</strong> ve <strong>filter</strong>. Bunların işlevleri aşağıdaki görseldeki gibi açıklanabilir.</p>
<p><center><img alt="2" src="/images/apache_spark/2/2.png"></center></p>
<p><em>Örnek : map()</em></p>
<div class="highlight"><pre><span></span><code>>>> nums = sc.parallelize([1, 2, 3, 4])
>>> squared = nums.map(lambda x: x * x).collect()
>>> squared
[1, 4, 9, 16]
</code></pre></div>
<p>gibi verilen parametredeki sayıların karesini alan bir örnek yazabiliriz.</p>
<p>Bazen <strong>map</strong> işleminin tersine her bir giriş ifadesine karşın birden fazla çıktı üretmek isteriz.Bu tip durumlarda kullanılan operasyon <strong>flatMap()</strong>'dir. Aşağıdaki örnek girdi olarak verilen metni basitçe kelimelerine ayırır.</p>
<p><em>Örnek : flatMap()</em></p>
<div class="highlight"><pre><span></span><code>>>> lines = sc.parallelize(["hello world", "hi"])
>>> words = lines.flatMap(lambda line: line.split(" "))
>>> words.first()
'hello'
</code></pre></div>
<p>Aşağıdaki görselde aynı işlemin <strong>map</strong> ve <strong>flatMap</strong> arasındaki farkı özetlenmektedir.</p>
<p><center><img alt="3" src="/images/apache_spark/2/3.png"></center></p>
<p>Transformation işlemlerini incelemeye devam edelim.</p>
<p><center><img alt="4" src="/images/apache_spark/2/4.png"></center></p>
<p>Yukarıdaki görseli açıklamak istersek kısaca,
- <strong>distinct</strong> işlemi ile tekrar eden kayıtları atarak geriye eşsiz kayıtlardan oluşan bir RDD elde edebiliriz.
- <strong>union</strong> işlemine daha önce değinmiştik.İki RDD'yi birleştirme işlevini görür fakat elemanların tekrarı ile ilgilenmediğine dikkat edin.
- <strong>intersection</strong> işlemi iki RDD arasındaki ortak elemanları elde etmemizi sağlar.
- <strong>subtract</strong> ile fonksiyona parametre olarak verilen RDD'deki elemamanlar dışındaki verileri elde ederiz.</p>
<p>Bunların dışında iki RDD arasında kartezyen çarpım da elde edebiliriz. Bunun için <code>RDD1.cartesian(RDD2)</code> uygulamamız yeterlidir.</p>
<h3>Eylemler(Actions)</h3>
<p>RDD oluşturmayı, var olan bir RDD'den yeni bir RDD yaratmayı transformation bölümünde gördük.Şimdi sıra veriler ile oynamada. Yapacağımız şey yukarıdaki örnekte elde ettiğimiz <strong>badLinesRDD</strong> içerisindeki '5' log satırını görüntülemek olsun.</p>
<p><em>Örnek : take()</em></p>
<div class="highlight"><pre><span></span><code><span class="nv">print</span><span class="ss">(</span><span class="nv">badLinesRDD</span>.<span class="nv">count</span><span class="ss">()</span>,<span class="s2">" lines"</span><span class="ss">)</span>
<span class="nv">print</span><span class="ss">(</span><span class="s2">"İşte beş örnek"</span><span class="ss">)</span>
<span class="k">for</span><span class="w"> </span><span class="nv">line</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">badLinesRDD</span>.<span class="nv">take</span><span class="ss">(</span><span class="mi">5</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">line</span><span class="ss">)</span>
</code></pre></div>
<p><strong>take()</strong> gibi birde <strong>collect()</strong> vardır fakat <strong>collect()</strong> kullanacaksanız veri boyutunun çok küçük olması gerektiği ve tek bir makinede çalışmanız gerektiğini unutmayın. Dolayısı ile <strong>collect()</strong> büyük veri kümelerinde çalışmak için uygun değildir.</p>
<p>Sanırım en çok kullanılan action <strong>reduce</strong>'dur. Kullanımı aşağıdaki gibidir.</p>
<p><code>sum = rdd.reduce(lambda x, y: x + y)</code></p>
<p>veya Python'da operator modülünü kullanabiliriz.</p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">operator</span> <span class="kn">import</span> <span class="n">add</span>
<span class="nb">sum</span> <span class="o">=</span> <span class="n">rdd</span><span class="o">.</span><span class="n">reduce</span><span class="p">(</span><span class="n">add</span><span class="p">)</span>
</code></pre></div>
<p>Dikkat ettiyseniz <em>reduce</em> fonksiyonu geriye içinde işlem yaptığımız RDD'nin sahip olduğu tipte bir değer döndürmektedir.Bu yukarıdaki gibi toplama işlemi gibi operasyonlar da başarılı fakat geriye tek bir değer değil bir ikili döndürmek isteyebiliriz.</p>
<p>Diğer basit action işlemlerini inceleyelim. İleride daha ayrıntılı bir biçimde tüm action işlemlerini inceleyeceğiz.</p>
<table>
<thead>
<tr>
<th>Fonksiyon</th>
<th>Açıklaması</th>
<th>Kullanım</th>
<th>Sonuç</th>
</tr>
</thead>
<tbody>
<tr>
<td>collect()</td>
<td>RDD'deki tüm elemanları döndürür</td>
<td>rdd.collect()</td>
<td>[1, 2, 3, 3]</td>
</tr>
<tr>
<td>count()</td>
<td>RDD'deki eleman sayılarını döndürür</td>
<td>rdd.count()</td>
<td>4</td>
</tr>
<tr>
<td>countByValue()</td>
<td>RDD içerisindeki her bir elemanın kaç defa geçtiğini bilgisini verir</td>
<td>rdd.countByValue()</td>
<td>[(1, 1),(2, 1),(3, 2)]</td>
</tr>
<tr>
<td>take(num)</td>
<td>RDD'den num sayısı kadar eleman döndürür</td>
<td>rdd.take(2)</td>
<td>[1, 2]</td>
</tr>
<tr>
<td>top(num, key=None)</td>
<td>RDD'den en büyük num sayısı kadar sayı döndürür</td>
<td>rdd.top(2)</td>
<td>[3, 3]</td>
</tr>
<tr>
<td>takeOrdered(num, key=None)</td>
<td>Parametlere olarak verilen sıralama şartına göre num adet sıralanmış örnek döndürür</td>
<td>rdd.takeOrdered(2)</td>
<td>[3, 3]</td>
</tr>
<tr>
<td>takeSample(withReplacement, num, [seed])</td>
<td>Rastgele n eleman döndürür</td>
<td>rdd.takeSample(True, 1, 1)</td>
<td>Kestirilemez</td>
</tr>
<tr>
<td>reduce(func)</td>
<td>Paralel olarak elemanları birleştirir</td>
<td>rdd.reduce(lambda x,y:x+y)</td>
<td>9</td>
</tr>
<tr>
<td>foreach(func)</td>
<td>Parametre olarak verilen fonksiyon tün elemanlar üzerinde uygulanır</td>
<td>rdd.foreach(func)</td>
<td></td>
</tr>
</tbody>
</table>
<h3>Önbellekleme(Caching)</h3>
<p>Spark RDD'lerinin "lazily evaluated" olduğundan bahsetmiştik. Bazen uygulamalarımızda bir RDD'yi birden fazla kez kullanmamız gerekebilir. Eğer bunu doğrudan yapıyor olsaydık, bizim her action isteğimizde, Spark bu RDD'yi ve bağımlılıklarını tekrar tekrar hesaplamak zorunda kalacaktı. Dolayısıyla iteratif algoritmaları kullanmamız gerektiğinde çok masraflı olacaktır. Bu konunun önemi çok fazladır, yazdığınız bir uygulama sorunsuz çalışıyor gibi gözükebilir fakat anlam veremediğiniz bir şekilde yavaş çalışıyorsa ilk olarak önbellekme konusunu incelemenizi tavsiye ederim. Bir örnek yapalım ve ne demek istediğimize bakalım.</p>
<p><em>Örnek : Çift hesaplamalı</em></p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">operator</span> <span class="kn">import</span> <span class="n">add</span>
<span class="kn">from</span> <span class="nn">pyspark</span> <span class="kn">import</span> <span class="n">SparkContext</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">sc</span> <span class="o">=</span> <span class="n">SparkContext</span><span class="p">(</span><span class="n">appName</span><span class="o">=</span><span class="s1">'myname'</span><span class="p">)</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="n">parallelize</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span> \
<span class="o">.</span><span class="n">map</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">data</span><span class="o">.</span><span class="n">count</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">','</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">data</span><span class="o">.</span><span class="n">collect</span><span class="p">()))</span>
</code></pre></div>
<p>Bu tip bir performans kaybı yerine, Spark'a bu datayı 'persist' edebilir misin diye sorarız.</p>
<p>Birden fazla seviye vardır.Genel olarak aşağıdaki gibi açıklanabilir.</p>
<table>
<thead>
<tr>
<th>Seviye</th>
<th>Yer kullanımı</th>
<th>CPU kullanımı</th>
<th>Bellekte mi?</th>
<th>Diskte mi?</th>
<th>Açıklama</th>
</tr>
</thead>
<tbody>
<tr>
<td>MEMORY_ONLY</td>
<td>Yüksek</td>
<td>Düşük</td>
<td>Evet</td>
<td>Hayır</td>
<td></td>
</tr>
<tr>
<td>MEMORY_ONLY_SER</td>
<td>Düşük</td>
<td>Yüksek</td>
<td>Evet</td>
<td>Hayır</td>
<td></td>
</tr>
<tr>
<td>MEMORY_AND_DISK</td>
<td>Yüksek</td>
<td>Orta</td>
<td>Birazı</td>
<td>Birazı</td>
<td>Veri bellek için fazla büyükse veri parçalarını diske koymaya başlar</td>
</tr>
<tr>
<td>MEMORY_AND_DISK_SER</td>
<td>Düşük</td>
<td>Yüksek</td>
<td>Birazı</td>
<td>Birazı</td>
<td>Veri bellek için fazla büyükse veri parçalarını diske koymaya başlar. Serilize edilerek saklanır</td>
</tr>
<tr>
<td>DISK_ONLY</td>
<td>Düşük</td>
<td>Yüksek</td>
<td>Hayır</td>
<td>Evet</td>
<td></td>
</tr>
</tbody>
</table>
<p><em>Örnek : Persist kullanımı</em></p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">operator</span> <span class="kn">import</span> <span class="n">add</span>
<span class="kn">from</span> <span class="nn">pyspark</span> <span class="kn">import</span> <span class="n">SparkContext</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">sc</span> <span class="o">=</span> <span class="n">SparkContext</span><span class="p">(</span><span class="n">appName</span><span class="o">=</span><span class="s1">'myname'</span><span class="p">)</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="n">parallelize</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span> \
<span class="o">.</span><span class="n">map</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span>
<span class="n">data</span><span class="o">.</span><span class="n">persist</span><span class="p">(</span><span class="n">StorageLevel</span><span class="o">.</span><span class="n">DISK_ONLY</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">data</span><span class="o">.</span><span class="n">count</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">','</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">data</span><span class="o">.</span><span class="n">collect</span><span class="p">()))</span>
</code></pre></div>
<p><strong>Not</strong>:persist() fonksiyonunun RDD henüz action ile karşılaşmadan önce çağrıldığına dikkat edin.</p>
<p>Eğer belleğe sığamayacak kadar veriyi önbelleklemeye çalışırsanız Spark otomatik olarak kendini Least Recently Used (LRU) politikasına göre düzenleyecektir.</p>
<p>Burada bahsedilenden çok daha fazla sayıda transformation ve action işlemi vardır. Çok daha ayrıntılı biçimde ileriki yazılarımda bahsedeceğim.</p>
<p>BURAK KÖSE</p>En uzun artan altdizi(LIS) - Dinamik Programlama2015-10-23T21:00:00+02:002015-10-23T21:00:00+02:00Buraktag:www.koseburak.net,2015-10-23:/blog/lis/<p>Bir dizi içerisinde en uzun artan altdiziyi bulmayı amaçlayan bir problemdir. Örneğin</p>
<div class="highlight"><pre><span></span><code>Input:
{10, 22, 9, 33, 21, 50, 41, 60, 80}
Output:
6{10, 22, 33, 50, 60, 80}
</code></pre></div>
<p><a href="https://www.koseburak.net/blog/lcs/">LCS</a> algoritmasına benzer bir yol izleyeceğiz. Kod anlaşılır durumda, çözüm aşağıdadır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">lis</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">lis</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">1</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i …</span></code></pre></div><p>Bir dizi içerisinde en uzun artan altdiziyi bulmayı amaçlayan bir problemdir. Örneğin</p>
<div class="highlight"><pre><span></span><code>Input:
{10, 22, 9, 33, 21, 50, 41, 60, 80}
Output:
6{10, 22, 33, 50, 60, 80}
</code></pre></div>
<p><a href="https://www.koseburak.net/blog/lcs/">LCS</a> algoritmasına benzer bir yol izleyeceğiz. Kod anlaşılır durumda, çözüm aşağıdadır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">lis</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">lis</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">1</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">))</span><span class="err">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">lis</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">lis</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="err">:</span>
<span class="w"> </span><span class="n">lis</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">lis</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nf">max</span><span class="p">(</span><span class="n">lis</span><span class="p">)</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">10, 22, 9, 33, 21, 50, 41, 60</span><span class="o">]</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">lis</span><span class="p">(</span><span class="n">arr</span><span class="p">))</span>
</code></pre></div>
<p>Yukarıdaki algoritmanın zaman karmaşıklığı <code>O(n^2)</code>'dir. Algoritma farklı bir yaklaşım ile <code>O(nlogn)</code> karmaşıklık ile çözülebilir. İncelemek için : <a href="http://en.wikipedia.org/wiki/Longest_increasing_subsequence#Efficient_algorithms">link</a></p>En uzun ortak altdizi(LCS) - Dinamik Programlama2015-10-20T18:00:00+02:002015-10-20T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-20:/blog/lcs/<p>Bilgisayar bilimlerinde önemli bir yere sahip olan bu problemde, verilen iki dizgide de ortak olarak bulunan ve aynı yönde sıralanmış dizgiler bütünü elde edilmeye çalışılmaktadır.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code> “ABCDGH” ve “AEDFHR” için “ADH”
“AGGTAB” ve “GXTXAYB” için “GTAB”
</code></pre></div>
<p>Dosyalar arasındaki farkları, değişiklikleri elde etmede ve özellikle bioinformatik alanında sıkça karşılaşılan bir çözümdür …</p><p>Bilgisayar bilimlerinde önemli bir yere sahip olan bu problemde, verilen iki dizgide de ortak olarak bulunan ve aynı yönde sıralanmış dizgiler bütünü elde edilmeye çalışılmaktadır.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code> “ABCDGH” ve “AEDFHR” için “ADH”
“AGGTAB” ve “GXTXAYB” için “GTAB”
</code></pre></div>
<p>Dosyalar arasındaki farkları, değişiklikleri elde etmede ve özellikle bioinformatik alanında sıkça karşılaşılan bir çözümdür. Çözüm aşağıdaki gibidir.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">lcs</span><span class="p">(</span><span class="n">s1</span><span class="p">,</span><span class="w"> </span><span class="n">s2</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">len_s1</span><span class="p">,</span><span class="w"> </span><span class="n">len_s2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">s1</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">s2</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">S</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">[0</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">len_s1</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">_</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">len_s2</span><span class="p">)</span><span class="err">]</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">len_s2</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">len_s1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">s1</span><span class="o">[</span><span class="n">j - 1</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">s2</span><span class="o">[</span><span class="n">i - 1</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">S</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">S</span><span class="o">[</span><span class="n">i - 1</span><span class="o">][</span><span class="n">j - 1</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="n">S</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">max</span><span class="p">(</span><span class="n">S</span><span class="o">[</span><span class="n">i - 1</span><span class="o">][</span><span class="n">j</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">S</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j - 1</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">S</span><span class="o">[</span><span class="n">len_s2 - 1</span><span class="o">][</span><span class="n">len_s1 - 1</span><span class="o">]</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">X</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"AGGTAB"</span>
<span class="w"> </span><span class="n">Y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"GXTXAYB"</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">lcs</span><span class="p">(</span><span class="n">X</span><span class="p">,</span><span class="w"> </span><span class="n">Y</span><span class="p">))</span>
</code></pre></div>
<p>Bu algoritmanın zaman karmaşıklığı <code>O(nm)</code>'dir. Peki hangi dizginin LCS olduğunu bulmak için ne yapmamız gerekiyor? Bunun için şu şekilde bir düzenleme ile sonuca ulaşabiliriz.</p>
<div class="highlight"><pre><span></span><code><span class="s s-Atom">def</span> <span class="nf">lcs</span><span class="p">(</span><span class="s s-Atom">s1</span><span class="p">,</span> <span class="s s-Atom">s2</span><span class="p">)</span><span class="o">:</span>
<span class="s s-Atom">len_s1</span><span class="p">,</span> <span class="s s-Atom">len_s2</span> <span class="o">=</span> <span class="nf">len</span><span class="p">(</span><span class="s s-Atom">s1</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nf">len</span><span class="p">(</span><span class="s s-Atom">s2</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="nv">S</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="s s-Atom">len_s1</span> <span class="s s-Atom">for</span> <span class="k">_</span> <span class="s s-Atom">in</span> <span class="nf">range</span><span class="p">(</span><span class="s s-Atom">len_s2</span><span class="p">)]</span>
<span class="s s-Atom">for</span> <span class="s s-Atom">i</span> <span class="s s-Atom">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s s-Atom">len_s2</span><span class="p">)</span><span class="o">:</span>
<span class="s s-Atom">for</span> <span class="s s-Atom">j</span> <span class="s s-Atom">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s s-Atom">len_s1</span><span class="p">)</span><span class="o">:</span>
<span class="s s-Atom">if</span> <span class="s s-Atom">s1</span><span class="p">[</span><span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="s s-Atom">s2</span><span class="p">[</span><span class="s s-Atom">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span>
<span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span><span class="p">][</span><span class="s s-Atom">j</span><span class="p">]</span> <span class="o">=</span> <span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
<span class="s s-Atom">else</span><span class="p">:</span>
<span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span><span class="p">][</span><span class="s s-Atom">j</span><span class="p">]</span> <span class="o">=</span> <span class="nf">max</span><span class="p">(</span><span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="s s-Atom">j</span><span class="p">],</span> <span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span><span class="p">][</span><span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">])</span>
<span class="s s-Atom">i</span><span class="p">,</span> <span class="s s-Atom">j</span> <span class="o">=</span> <span class="s s-Atom">len_s2</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="s s-Atom">len_s1</span> <span class="o">-</span> <span class="mi">1</span>
<span class="s s-Atom">result</span> <span class="o">=</span> <span class="s2">""</span>
<span class="s s-Atom">while</span> <span class="s s-Atom">i</span> <span class="o">></span> <span class="mi">0</span> <span class="s s-Atom">and</span> <span class="s s-Atom">j</span> <span class="o">></span> <span class="mi">0</span><span class="o">:</span>
<span class="s s-Atom">if</span> <span class="s s-Atom">s1</span><span class="p">[</span><span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="s s-Atom">s2</span><span class="p">[</span><span class="s s-Atom">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span>
<span class="s s-Atom">result</span> <span class="s s-Atom">+=</span> <span class="s s-Atom">s1</span><span class="p">[</span><span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
<span class="s s-Atom">i</span><span class="p">,</span> <span class="s s-Atom">j</span> <span class="o">=</span> <span class="s s-Atom">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span>
<span class="s s-Atom">elif</span> <span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="s s-Atom">j</span><span class="p">]</span> <span class="o">></span> <span class="nv">S</span><span class="p">[</span><span class="s s-Atom">i</span><span class="p">][</span><span class="s s-Atom">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span>
<span class="s s-Atom">i</span> <span class="s s-Atom">-=</span> <span class="mi">1</span>
<span class="s s-Atom">else</span><span class="p">:</span>
<span class="s s-Atom">j</span> <span class="s s-Atom">-=</span> <span class="mi">1</span>
<span class="s s-Atom">return</span> <span class="nv">S</span><span class="p">[</span><span class="s s-Atom">len_s2</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="s s-Atom">len_s1</span> <span class="o">-</span> <span class="mi">1</span><span class="p">],</span> <span class="s s-Atom">result</span><span class="p">[</span><span class="o">::-</span><span class="mi">1</span><span class="p">]</span>
<span class="s s-Atom">if</span> <span class="k">__</span><span class="s s-Atom">name__</span> <span class="o">==</span> <span class="s s-Atom">'__main__'</span><span class="o">:</span>
<span class="nv">X</span> <span class="o">=</span> <span class="s2">"AGGTAB"</span>
<span class="nv">Y</span> <span class="o">=</span> <span class="s2">"GXTXAYB"</span>
<span class="nf">print</span><span class="p">(</span><span class="nf">lcs</span><span class="p">(</span><span class="nv">X</span><span class="p">,</span> <span class="nv">Y</span><span class="p">))</span>
</code></pre></div>
<p>Çok daha ayrıntılı bir inceleme için <a href="https://en.wikipedia.org/wiki/Longest_common_subsequence_problem">Wiki</a> sayfasından yardım alabilirsiniz.</p>Sieve of Eratosthenes - Matematik Problemi2015-10-20T16:00:00+02:002015-10-20T16:00:00+02:00Buraktag:www.koseburak.net,2015-10-20:/blog/sieve-of-eratosthenes/<p>Verilen bir <code>n</code> sayısı var ve bu sayıya kadar olan tüm asal sayıların elde edilmesi için sunulmuş en efektif çözümdür <a href="https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes">(ref: Wiki)</a>.</p>
<p><img alt="gif" src="https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif"></p>
<p>Algoritma şu şekilde çalışır.</p>
<ol>
<li>2'den n'e kadar bir liste yaratılır. (2,3,4,5,6...n)</li>
<li>p = 2 yapılarak ilk asal sayı 2 ilan edilir.</li>
<li>2p,3p,4p …</li></ol><p>Verilen bir <code>n</code> sayısı var ve bu sayıya kadar olan tüm asal sayıların elde edilmesi için sunulmuş en efektif çözümdür <a href="https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes">(ref: Wiki)</a>.</p>
<p><img alt="gif" src="https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif"></p>
<p>Algoritma şu şekilde çalışır.</p>
<ol>
<li>2'den n'e kadar bir liste yaratılır. (2,3,4,5,6...n)</li>
<li>p = 2 yapılarak ilk asal sayı 2 ilan edilir.</li>
<li>2p,3p,4p,5p ... gibi katlar alınarak bu sayılar işaretlenir ve asal sayılardan dışlanmış olunur</li>
<li>iaşretlenmemiş ilk sayı bulunarak p'ye atanır ve işlemler tekrar edilir.</li>
</ol>
<p>Çözüm aşağıdaki gibi olur.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">mark</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">n</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">num - 1</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">n</span>
<span class="n">def</span><span class="w"> </span><span class="n">sieve_of_eratosthenes</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">2</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">n</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
<span class="w"> </span><span class="n">mark</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span>
<span class="w"> </span><span class="n">sieve_of_eratosthenes</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>
</code></pre></div>
<p>Agoritmanın anlaşılırlığı için kod uzun tutulmuştur. Çok daha fazla kısaltılması mümkündür.</p>Sayının faktoriyelinde sonda bulunan 0'ların sayısı - Matematik Problemi2015-10-20T14:00:00+02:002015-10-20T14:00:00+02:00Buraktag:www.koseburak.net,2015-10-20:/blog/faktoriyel-0s-count/<p>Verilen sayının faktoriyelinde sonda bulunan sıfırların sayısını bulmamız gerekiyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">5</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">1</span>
<span class="mi">5</span><span class="o">!</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">4</span>
<span class="mi">20</span><span class="o">!</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2432902008176640000</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">100</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">24</span>
</code></pre></div>
<p>En basit hali ile çözüm, sayının faktoriyelini hesaplamak ve sondaki sıfıların sayısını saymak. Masraflı ve büyük sayılar için çalışmayacak bir yöntem …</p><p>Verilen sayının faktoriyelinde sonda bulunan sıfırların sayısını bulmamız gerekiyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">5</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">1</span>
<span class="mi">5</span><span class="o">!</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">4</span>
<span class="mi">20</span><span class="o">!</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2432902008176640000</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">100</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">24</span>
</code></pre></div>
<p>En basit hali ile çözüm, sayının faktoriyelini hesaplamak ve sondaki sıfıların sayısını saymak. Masraflı ve büyük sayılar için çalışmayacak bir yöntem.</p>
<p>Matematikten faydalanarak şu şekilde çözebiliriz. Sayının sonunda 0 oluşabilmesi için en az bir adet 2 ve bir adet 5 gerekmektedir. Dolayısı ile sayı içerisindeki 2lerin ve 5lerin sayısını sayarsak çözüme ulaşabiliriz.</p>
<div class="highlight"><pre><span></span><code>n = 5: Bir adet 5 ve üç adet 2 bulunmaktadır (2 * 2 * 2 * 3 * 5). Dolayısıyla 0ların sayısı 1'dir.
n = 11: İki adet 5 ve üç adet 2 bulunmaktadır. (2^8 * 3^4 * 5^2 * 7). Dolayısıyla 0ların sayısı 2'dir.
</code></pre></div>
<p>Sayı içerisindeki 2lerin sayısı es geçebiliriz zaten her seferinde elimizde fazladan 2 olacak. Sadece 5lerin sayısını saymak yeterlidir. Dikkat etmemiz gereken başka bir durum bulunmaktadır. Örneğin 28! sayısı için 25 sayısından gelen fazladan bir 5 durumu vardır. Aynı durum 125 yani 5'in üsleri içinde geçerlidir.</p>
<p><code>n! için sondaki sıfır sayısı = floor(n/5) + floor(n/25) + floor(n/125) + ....</code></p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">count_zeros</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">5</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">1</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="nv">i</span>
<span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="mi">5</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">result</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">100</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">count_zeros</span><span class="ss">(</span><span class="nv">n</span><span class="ss">))</span>
</code></pre></div>Hileli parayı hilesiz yapmak - Matematik Problemi2015-10-20T12:00:00+02:002015-10-20T12:00:00+02:00Buraktag:www.koseburak.net,2015-10-20:/blog/0-1-50/<p>Verilen bir fonksiyon yazı tura işlemini %60 yazı %40 tura gelecek şekilde gerçekleştiriyor. Bu verilen fonksiyonu kullanarak bu işlemi nasıl hilesiz yapabiliriz?</p>
<p>Paranın %60 olasılıkla 0, %40 olasılık ile 1 döndürdüğünü biliyoruz. Çözüm olarak bu fonksiyonu iki kere çağıracağız. Eğer sonuçlar (1,0) veya (0,1) ise problem yok, direk …</p><p>Verilen bir fonksiyon yazı tura işlemini %60 yazı %40 tura gelecek şekilde gerçekleştiriyor. Bu verilen fonksiyonu kullanarak bu işlemi nasıl hilesiz yapabiliriz?</p>
<p>Paranın %60 olasılıkla 0, %40 olasılık ile 1 döndürdüğünü biliyoruz. Çözüm olarak bu fonksiyonu iki kere çağıracağız. Eğer sonuçlar (1,0) veya (0,1) ise problem yok, direk cevabı vereceğiz fakat cevaplar (1,1) veya (0,0) ise işlemi tekrarlayacağız.</p>
<div class="highlight"><pre><span></span><code>(0, 1): 0 sonrası 1 gelme olasılığı = 0.6 * 0.4 = 0.24
(1, 0): 1 sonrası 0 gelme olasılığı = 0.4 * 0.6 = 0.24
</code></pre></div>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">foo</span><span class="ss">()</span>:
<span class="w"> </span><span class="s1">'Bu method hileli olarak 1 veya 0 döndürür'</span>
<span class="w"> </span><span class="nv">pass</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">my_foo</span><span class="ss">()</span>:
<span class="w"> </span><span class="nv">val1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">foo</span><span class="ss">()</span>
<span class="w"> </span><span class="nv">val2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">foo</span><span class="ss">()</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">val1</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="nv">and</span><span class="w"> </span><span class="nv">val2</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">1</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span>#<span class="w"> </span><span class="mi">0</span>.<span class="mi">24</span><span class="w"> </span><span class="nv">olasılık</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">val1</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="nv">and</span><span class="w"> </span><span class="nv">val2</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span>#<span class="w"> </span><span class="mi">0</span>.<span class="mi">24</span><span class="w"> </span><span class="nv">olasılık</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">my_foo</span><span class="ss">()</span><span class="w"> </span>#<span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">0</span>.<span class="mi">24</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">0</span>.<span class="mi">24</span><span class="w"> </span><span class="nv">olasılık</span>
</code></pre></div>Hedef puana kaç farklı şekilde ulaşılır? - Dinamik Programlama2015-10-19T23:00:00+02:002015-10-19T23:00:00+02:00Buraktag:www.koseburak.net,2015-10-19:/blog/nth-score/<p>3, 5 ve 10 puan almanın mümkün olduğu ve hedef puana bu puan gruplarını kullanarak kaç farklı şekilde ulaşılabileceğini bulacağız.</p>
<p>Örnek;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">4</span>
<span class="o">(</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">)</span>
<span class="o">(</span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">)</span>
<span class="o">(</span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
<span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">13</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
<span class="o">(</span><span class="mi">3 …</span></code></pre></div><p>3, 5 ve 10 puan almanın mümkün olduğu ve hedef puana bu puan gruplarını kullanarak kaç farklı şekilde ulaşılabileceğini bulacağız.</p>
<p>Örnek;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">4</span>
<span class="o">(</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">)</span>
<span class="o">(</span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">)</span>
<span class="o">(</span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
<span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">13</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
<span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">)</span>
</code></pre></div>
<p>Çözüm mantığı gayet basittir. n+1 boyutunda bir dizi yaratılır ve her puanlama için döngüler ile tüm çözüm sayıları tutulur. Zaman ve yer karmaşıklığı 0(n) olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">adjust</span><span class="p">(</span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">score</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">score</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">l</span><span class="o">[</span><span class="n">i - score</span><span class="o">]</span>
<span class="n">def</span><span class="w"> </span><span class="nf">count</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="p">(</span><span class="n">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
<span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="n">puan</span><span class="w"> </span><span class="n">için</span>
<span class="w"> </span><span class="n">adjust</span><span class="p">(</span><span class="k">result</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">)</span>
<span class="w"> </span><span class="n">adjust</span><span class="p">(</span><span class="k">result</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">)</span>
<span class="w"> </span><span class="n">adjust</span><span class="p">(</span><span class="k">result</span><span class="p">,</span><span class="w"> </span><span class="mi">10</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">n</span><span class="o">]</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">score</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="nf">count</span><span class="p">(</span><span class="n">score</span><span class="p">))</span>
</code></pre></div>
<p>Cevabı doğru bulduk fakat (10, 5, 5), (5, 5, 10) ve (5, 10, 5) durumları tek bir durum olarak sayılmıştır. Peki bu durumlarıda farklı birer yol olarak saymak istersek yukarıdaki kodu biraz değiştirmek gerekecek.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">count_new</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="p">(</span><span class="n">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
<span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="n">puan</span><span class="w"> </span><span class="n">için</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">3</span><span class="err">:</span>
<span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">i - 3</span><span class="o">]</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">5</span><span class="err">:</span>
<span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">i - 5</span><span class="o">]</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">10</span><span class="err">:</span>
<span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">i - 10</span><span class="o">]</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">n</span><span class="o">]</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">score</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">count_new</span><span class="p">(</span><span class="n">score</span><span class="p">))</span>
</code></pre></div>N. basamağa kaç adımda ulaşılabilir? - Dinamik Programlama2015-10-19T23:00:00+02:002015-10-19T23:00:00+02:00Buraktag:www.koseburak.net,2015-10-19:/blog/nth-stair/<p>N adet basamağa sahip bir merdivende, en alt noktadan üst noktaya her seferinde en fazla bir veya iki adım atarak kaç farklı şekilde ulaşabileceğimizi bulacağız.</p>
<p><img alt="basamak" src="/images/DynamicProgramming/stairs.gif"> Örneğin yadaki resim için 3 adet çözüm vardır.</p>
<p>Daha fazla örnek;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">1</span>
<span class="n">Sadece</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">adımda</span><span class="w"> </span><span class="n">ulaşılır</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2 …</span></code></pre></div><p>N adet basamağa sahip bir merdivende, en alt noktadan üst noktaya her seferinde en fazla bir veya iki adım atarak kaç farklı şekilde ulaşabileceğimizi bulacağız.</p>
<p><img alt="basamak" src="/images/DynamicProgramming/stairs.gif"> Örneğin yadaki resim için 3 adet çözüm vardır.</p>
<p>Daha fazla örnek;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">1</span>
<span class="n">Sadece</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">adımda</span><span class="w"> </span><span class="n">ulaşılır</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="err">İ</span><span class="n">ki</span><span class="w"> </span><span class="n">farklı</span><span class="w"> </span><span class="n">adımda</span><span class="w"> </span><span class="n">ulaşılır</span><span class="o">:</span><span class="w"> </span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">)</span><span class="w"> </span><span class="n">ve</span><span class="w"> </span><span class="o">(</span><span class="mi">2</span><span class="o">)</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">5</span>
<span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">),</span><span class="w"> </span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">2</span><span class="o">),</span><span class="w"> </span><span class="o">(</span><span class="mi">2</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">),</span><span class="w"> </span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">2</span><span class="o">,</span><span class="w"> </span><span class="mi">1</span><span class="o">),</span><span class="w"> </span><span class="o">(</span><span class="mi">2</span><span class="o">,</span><span class="w"> </span><span class="mi">2</span><span class="o">)</span>
</code></pre></div>
<p>Basit olarak rekürsif olarak çözebilir. <code>yol(n) = yol(n-1) + yol(n-2)</code> . Aslında yandaki formulun <a href="https://www.koseburak.net/blog/fibonacci/">fibonacci</a> formulu olduğu çok belli.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="mi">1</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">n</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">solve</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">solve</span><span class="ss">(</span><span class="nv">n</span><span class="ss">))</span>
</code></pre></div>
<p>Yukarıdaki çözüm O(2^n) zaman karmaşasına sahiptir. Tabi çok daha efektif çözmenin yollarını <a href="https://www.koseburak.net/blog/fibonacci/">şurada</a> daha önce belirttim.</p>
<h4>Problemin genelleştirilmiş hali</h4>
<p>Örneğin kişinin m adıma kadar hakkı olsun. m=4 için kişi her bir anda 1, 2, 3 veya 4 adım atabilir.
<code>yol(n, m) = yol(n-1, m) + yol(n-2, m) + ... yol(n-m, m)</code></p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">calculate</span><span class="ss">(</span><span class="nv">n</span>,<span class="w"> </span><span class="nv">m</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="mi">1</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">n</span>
<span class="w"> </span><span class="nv">res</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="nv">m</span><span class="w"> </span><span class="nv">and</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="nv">n</span>:
<span class="w"> </span><span class="nv">res</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="nv">calculate</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="nv">i</span>,<span class="w"> </span><span class="nv">m</span><span class="ss">)</span>
<span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">res</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">solve_gen</span><span class="ss">(</span><span class="nv">n</span>,<span class="w"> </span><span class="nv">m</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">calculate</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>,<span class="w"> </span><span class="nv">m</span><span class="ss">)</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">basamak</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span>
<span class="w"> </span><span class="nv">adim</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">solve_gen</span><span class="ss">(</span><span class="nv">basamak</span>,<span class="w"> </span><span class="nv">adim</span><span class="ss">))</span>
</code></pre></div>Fibonacci sayısı oluşturma - Matematik Problemi2015-10-18T18:00:00+02:002015-10-18T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-18:/blog/fibonacci/<p>Fibonacci sayılarını oluşturmanın birden fazla yöntemi vardır.</p>
<p><code>0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 141, ……..</code></p>
<p><code>Fn = Fn-1 + Fn-2</code></p>
<p><code>F0 = 0 and F1 = 1.</code></p>
<h3>Metot 1 ( recursion )</h3>
<p>Yukarıda verilmiş olan matematik ifadesinin direkt olarak uygulanmış halidir. İşe yarar ama çok fazla maliyetlidir.</p>
<p><code>T(n) = T(n-1 …</code></p><p>Fibonacci sayılarını oluşturmanın birden fazla yöntemi vardır.</p>
<p><code>0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 141, ……..</code></p>
<p><code>Fn = Fn-1 + Fn-2</code></p>
<p><code>F0 = 0 and F1 = 1.</code></p>
<h3>Metot 1 ( recursion )</h3>
<p>Yukarıda verilmiş olan matematik ifadesinin direkt olarak uygulanmış halidir. İşe yarar ama çok fazla maliyetlidir.</p>
<p><code>T(n) = T(n-1) + T(n-2)</code> karmaşıklık analizi çözüldüğünde karşımıza <code>O(2^n)</code> çıkar. Gerçekten maliyetli bir çözüm!</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="mi">1</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">n</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">9</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">recursion</span><span class="ss">(</span><span class="nv">n</span><span class="ss">))</span>
</code></pre></div>
<h3>Metot 2 (Dynamic Programming)</h3>
<p>Metot 1'deki öz yinelemeli çözümde aynı değerleri defalarca hesapladıımızı görmüşsünüzdür. Bu işlemi önlemek amaçlı dinamik programlama yaklaşımına bakacağız.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="k">dynamic</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">fib_list</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">0, 1</span><span class="o">]</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">fib_list</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">fib_list</span><span class="o">[</span><span class="n">i - 1</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">fib_list</span><span class="o">[</span><span class="n">i - 2</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">fib_list</span><span class="o">[</span><span class="n">n</span><span class="o">]</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">9</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="k">dynamic</span><span class="p">(</span><span class="n">n</span><span class="p">))</span>
</code></pre></div>
<p>Bu çözümün zaman karmaşıklığı <code>O(n)</code> ve yer karmaşıklığı <code>O(n)</code> olmaktadır.</p>
<h3>Metot 3 (Metot 2 için yer düzenlemesi)</h3>
<p>Metot 2'de yapılan çözüm yer karmaşıklığına sahiptir. Yani ekstra bellek kullanımı gerektiren bir çözümdür. Bu çözümü aynı proramlama paradigması ile yerden ödün vermeyerek şu şekilde çözebiliriz.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">space_dynamic</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">a</span>,<span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>,<span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">a</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">range</span><span class="ss">(</span><span class="mi">2</span>,<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">a</span>,<span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">b</span>,<span class="w"> </span><span class="nv">a</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">b</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">b</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">9</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">space_dynamic</span><span class="ss">(</span><span class="nv">n</span><span class="ss">))</span>
</code></pre></div>
<h3>Metot 4</h3>
<p>Bir başka <code>O(n)</code> çözüme sahip bir çözüm olan bu çözümde elimizde bir matris var.</p>
<p><code>M = [[1,1],[1,0]]</code></p>
<p>n. fibonacci sayısını istiyorsak bu matrisi kendisi ile n kere çarpmamız ve (0,0) elemanını almamız gerekmektedir. Kısacası pow(M,n) işlemi yapmamız gerekmektedir.</p>
<p><img alt="Matris" src="/images/MathematicalAlgorithm/fibonaccimatrix.png"></p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">matrix</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">F</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>[[<span class="mi">1</span>,<span class="w"> </span><span class="mi">1</span>],<span class="w"> </span>[<span class="mi">1</span>,<span class="w"> </span><span class="mi">0</span>]]
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">not</span><span class="w"> </span><span class="nv">n</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="nv">power</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]
<span class="nv">def</span><span class="w"> </span><span class="nv">power</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">M</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>[[<span class="mi">1</span>,<span class="w"> </span><span class="mi">1</span>],<span class="w"> </span>[<span class="mi">1</span>,<span class="w"> </span><span class="mi">0</span>]]
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">range</span><span class="ss">(</span><span class="mi">2</span>,<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">M</span><span class="ss">)</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">M</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">0</span>]
<span class="w"> </span><span class="nv">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">1</span>]
<span class="w"> </span><span class="nv">z</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">0</span>]
<span class="w"> </span><span class="nv">w</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">1</span>]
<span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">x</span>
<span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">y</span>
<span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">z</span>
<span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">w</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">9</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">matrix</span><span class="ss">(</span><span class="nv">n</span><span class="ss">))</span>
</code></pre></div>
<p>Zaman karmaşıklığı <code>O(n)</code> ve yer karmaşıklığı <code>O(1)</code> olur.</p>
<h3>Metot 5 (Metot 4 iyileştirmesi)</h3>
<p>Bu adım ile artık n. fibonacci sayısını bulma işlemini <code>O(logn)</code> karmaşıklıkta çözebileceğiz.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">matrix_opt</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">F</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>[[<span class="mi">1</span>,<span class="w"> </span><span class="mi">1</span>],<span class="w"> </span>[<span class="mi">1</span>,<span class="w"> </span><span class="mi">0</span>]]
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">not</span><span class="w"> </span><span class="nv">n</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="nv">power</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]
<span class="nv">def</span><span class="w"> </span><span class="nv">power_opt</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="nv">and</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">1</span>:
<span class="w"> </span><span class="k">return</span>
<span class="w"> </span><span class="nv">M</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>[[<span class="mi">1</span>,<span class="w"> </span><span class="mi">1</span>],<span class="w"> </span>[<span class="mi">1</span>,<span class="w"> </span><span class="mi">0</span>]]
<span class="w"> </span><span class="nv">power_opt</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span>
<span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">F</span><span class="ss">)</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">M</span><span class="ss">)</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">F</span>,<span class="w"> </span><span class="nv">M</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">0</span>]
<span class="w"> </span><span class="nv">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">1</span>]
<span class="w"> </span><span class="nv">z</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">0</span>]
<span class="w"> </span><span class="nv">w</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">M</span>[<span class="mi">1</span>][<span class="mi">1</span>]
<span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">x</span>
<span class="w"> </span><span class="nv">F</span>[<span class="mi">0</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">y</span>
<span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">0</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">z</span>
<span class="w"> </span><span class="nv">F</span>[<span class="mi">1</span>][<span class="mi">1</span>]<span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">w</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">9</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">matrix_opt</span><span class="ss">(</span><span class="nv">n</span><span class="ss">))</span>
</code></pre></div>Sıralı olarak verilmiş üç diziden ortak elemanları bulma - Arama Algoritması2015-10-18T18:00:00+02:002015-10-18T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-18:/blog/search-common-element-three/<p>Artan sırada verilmiş üç dizi içerisinde bulunan ortak elemanı bulmamıza yarayan algoritmaya bakacağız.</p>
<p>Örneğin</p>
<div class="highlight"><pre><span></span><code>ar1[] = {1, 5, 10, 20, 40, 80}
ar2[] = {6, 7, 20, 80, 100}
ar3[] = {3, 4, 15, 20, 30, 70, 80, 120}
Output: 20, 80
ar1[] = {1, 5, 5}
ar2[] = {3, 4, 5, 5, 10}
ar3 …</code></pre></div><p>Artan sırada verilmiş üç dizi içerisinde bulunan ortak elemanı bulmamıza yarayan algoritmaya bakacağız.</p>
<p>Örneğin</p>
<div class="highlight"><pre><span></span><code>ar1[] = {1, 5, 10, 20, 40, 80}
ar2[] = {6, 7, 20, 80, 100}
ar3[] = {3, 4, 15, 20, 30, 70, 80, 120}
Output: 20, 80
ar1[] = {1, 5, 5}
ar2[] = {3, 4, 5, 5, 10}
ar3[] = {5, 5, 10, 20}
Output: 5, 5
</code></pre></div>
<p>Basit olarak ilk çözüm <a href="http://www.geeksforgeeks.org/union-and-intersection-of-two-sorted-arrays-2/">link!</a> algoritmasını uygulamak ve elde edilen değerleri yedek bir dizi içerisinde tutmaktır. Bu çözüm ile karmaşıklık O(n1+n2+n3) olacaktır.</p>
<p>Yukarıda ki çözüm ekstra olarak hafıza ve iki adet döngü içermektedir. Oysa bu soruyu tek bir döngüde ve ektra hafıza gerektirmeden çözebiliriz.</p>
<p>Çözüm aşağıdaki gibidir.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">find_common</span><span class="p">(</span><span class="n">ar1</span><span class="p">,</span><span class="w"> </span><span class="n">ar2</span><span class="p">,</span><span class="w"> </span><span class="n">ar3</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="n">n1</span><span class="p">,</span><span class="w"> </span><span class="n">n2</span><span class="p">,</span><span class="w"> </span><span class="n">n3</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">ar1</span><span class="p">),</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">ar2</span><span class="p">),</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">ar3</span><span class="p">)</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">n1</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">n2</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nl">n3</span><span class="p">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">ar1</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">ar2</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">ar2</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">ar3</span><span class="o">[</span><span class="n">k</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">ar1</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">elif</span><span class="w"> </span><span class="n">ar1</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">ar2</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">elif</span><span class="w"> </span><span class="n">ar2</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">ar3</span><span class="o">[</span><span class="n">k</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">ar1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">1, 5, 10, 20, 40, 80</span><span class="o">]</span>
<span class="w"> </span><span class="n">ar2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">6, 7, 20, 80, 100</span><span class="o">]</span>
<span class="w"> </span><span class="n">ar3</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">3, 4, 15, 20, 30, 70, 80, 120</span><span class="o">]</span>
<span class="w"> </span><span class="n">find_common</span><span class="p">(</span><span class="n">ar1</span><span class="p">,</span><span class="w"> </span><span class="n">ar2</span><span class="p">,</span><span class="w"> </span><span class="n">ar3</span><span class="p">)</span>
</code></pre></div>
<p>Karmaşıklık O(n1+n2+n3) olacaktır.</p>Suffix Array - String Algoritmaları2015-10-18T18:00:00+02:002015-10-18T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-18:/blog/suffix-array/<p>Suffix dizisi, verilmiş olarak verilen stringe ait tüm suffixlerin alfabetik olarak sıralanmış halidir. Suffix array eğer elinizde bir suffix tree varsa, bu ağaç üzerinde DFS algoritmasını işletilmesi ile elde edilebilir.</p>
<p>Suffix array veri yapısının, suffix tree'den avantajları, geliştirilmiş bellek performansı ve keşleme özelliğidir.</p>
<p>Önreğin;</p>
<div class="highlight"><pre><span></span><code><span class="s">"banana"</span><span class="w"> </span><span class="n">için</span><span class="p">.</span>
<span class="mi">0</span><span class="w"> </span><span class="n">banana</span><span class="w"> </span><span class="mi">5</span><span class="w"> </span><span class="n">a …</span></code></pre></div><p>Suffix dizisi, verilmiş olarak verilen stringe ait tüm suffixlerin alfabetik olarak sıralanmış halidir. Suffix array eğer elinizde bir suffix tree varsa, bu ağaç üzerinde DFS algoritmasını işletilmesi ile elde edilebilir.</p>
<p>Suffix array veri yapısının, suffix tree'den avantajları, geliştirilmiş bellek performansı ve keşleme özelliğidir.</p>
<p>Önreğin;</p>
<div class="highlight"><pre><span></span><code><span class="s">"banana"</span><span class="w"> </span><span class="n">için</span><span class="p">.</span>
<span class="mi">0</span><span class="w"> </span><span class="n">banana</span><span class="w"> </span><span class="mi">5</span><span class="w"> </span><span class="n">a</span>
<span class="mi">1</span><span class="w"> </span><span class="n">anana</span><span class="w"> </span><span class="n">Suffixes</span><span class="w"> </span><span class="n">sırala</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="n">ana</span>
<span class="mi">2</span><span class="w"> </span><span class="n">nana</span><span class="w"> </span><span class="o">----------------></span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">anana</span><span class="w"> </span>
<span class="mi">3</span><span class="w"> </span><span class="n">ana</span><span class="w"> </span><span class="n">alfabetik</span><span class="w"> </span><span class="n">olarak</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="n">banana</span><span class="w"> </span>
<span class="mi">4</span><span class="w"> </span><span class="n">na</span><span class="w"> </span><span class="mi">4</span><span class="w"> </span><span class="n">na</span><span class="w"> </span>
<span class="mi">5</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="n">nana</span>
<span class="s">"banana"</span><span class="w"> </span><span class="n">için</span><span class="w"> </span><span class="n">suffix</span><span class="w"> </span><span class="n">dizisi</span><span class="w"> </span><span class="p">{</span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">}</span><span class="w"> </span><span class="n">olur</span><span class="p">.</span>
</code></pre></div>
<h3>Suffix Array oluşturmak için temel metot</h3>
<p>Açıkçası yukarıdaki örnek yeterince açık, basit bir kaç core fonksiyon sayesinde oluşturulabilecek bir algoritma. Ben biraz işin kolayına kaçarak Python'da basit şekilde oluşturacağım.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">build_suffix_array</span><span class="ss">(</span><span class="nv">text</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">sorted</span><span class="ss">(</span><span class="nv">range</span><span class="ss">(</span><span class="nv">len</span><span class="ss">(</span><span class="nv">text</span><span class="ss">))</span>,<span class="w"> </span><span class="nv">key</span><span class="o">=</span><span class="nv">lambda</span><span class="w"> </span><span class="nv">x</span>:<span class="w"> </span><span class="nv">text</span>[<span class="nv">x</span>:]<span class="ss">)</span>
</code></pre></div>
<p>Yukarıdaki algoritma <code>O(n^2logn)</code> zaman karmaşıklığında çalışmaktadır. Suffix array oluşturmak içi çok daha verimli algoritmalar bulunmaktadır!</p>
<h3>Arama işlemi</h3>
<p>Elimizde aslında sıralanmış bir string dizisi var gibi düşünebiliriz ve sıralanmış bir dizi içerisinde arama yapma işleminde herkesin muhtemelen aklına gelen algoritma <code>Binary Search</code> algoritmasıdır. Bu işlemdede bu algoritmayı kullanacağız.</p>
<p>Çözüm aşağıdaki gibi olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="k">search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">,</span><span class="w"> </span><span class="n">suffs</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nl">l</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span>
<span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="p">(</span><span class="n">r</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">l</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="n">t</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nc">text</span><span class="o">[</span><span class="n">suffs[mid</span><span class="o">]</span><span class="err">:]</span><span class="o">[</span><span class="n">:len(pattern)</span><span class="o">]</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pattern</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nl">t</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">suffs</span><span class="o">[</span><span class="n">mid</span><span class="o">]</span>
<span class="w"> </span><span class="n">elif</span><span class="w"> </span><span class="n">pattern</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="nl">t</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="k">search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">,</span><span class="w"> </span><span class="n">suffs</span><span class="p">,</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">)</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="k">search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">,</span><span class="w"> </span><span class="n">suffs</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="nc">text</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"banana"</span>
<span class="w"> </span><span class="n">pattern</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"anan"</span>
<span class="w"> </span><span class="n">suffix_array</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">build_suffix_array</span><span class="p">(</span><span class="nc">text</span><span class="p">)</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="k">search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">,</span><span class="w"> </span><span class="n">suffix_array</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="nc">text</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">))</span>
</code></pre></div>
<p>Yukarıdaki arama algoritması <code>O(mlogn)</code>'dir. Gerçek şu ki suffix array veri yapısı için çok daha verimli tanımlamalar vardır. Bu gerçekten çok basit bir giriştir ve olayın genel mantığı için</p>Sıralı iki dizi içerisinde seçilen ikili toplamının hedef sayıya en yakın olması - Arama Algoritması2015-10-17T18:00:00+02:002015-10-17T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-17:/blog/find-closest-pair-sorted/<p>Hoşuma giden problem türlerinden olan yakın ikili sorularından biri. Bu problemde girdi olarak verilen iki tane sıralanmış dizi ve bir hedef numarası bulunuyor ve dizilerden seçilen hangi iki elemanın toplamının hedef elemana en yakın sayı olacağını bulmamız gerekiyor.</p>
<p>Örnek olarak;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">ar1</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">7</span><span class="o">};</span>
<span class="w"> </span><span class="n">ar2</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">30 …</span></code></pre></div><p>Hoşuma giden problem türlerinden olan yakın ikili sorularından biri. Bu problemde girdi olarak verilen iki tane sıralanmış dizi ve bir hedef numarası bulunuyor ve dizilerden seçilen hangi iki elemanın toplamının hedef elemana en yakın sayı olacağını bulmamız gerekiyor.</p>
<p>Örnek olarak;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">ar1</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">7</span><span class="o">};</span>
<span class="w"> </span><span class="n">ar2</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">30</span><span class="o">,</span><span class="w"> </span><span class="mi">40</span><span class="o">};</span>
<span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">32</span><span class="w"> </span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">and</span><span class="w"> </span><span class="mi">30</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">ar1</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">5</span><span class="o">,</span><span class="w"> </span><span class="mi">7</span><span class="o">};</span>
<span class="w"> </span><span class="n">ar2</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">30</span><span class="o">,</span><span class="w"> </span><span class="mi">40</span><span class="o">};</span>
<span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">50</span><span class="w"> </span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">7</span><span class="w"> </span><span class="n">and</span><span class="w"> </span><span class="mi">40</span>
</code></pre></div>
<p>gibi.</p>
<p>Eğer dizilerin birinin <code>n</code> elemanlı diğerinin <code>m</code> elemanlı (n=m olabilir) olduğunu varsayarsak en ilkkel çözüm şu şekilde olacaktır. İki tane döngü kurarak karşılıklı olarak tüm ihtimalleri deneyerek cevaba ulaşmaya çalışırız. Tabi bu çözümde verilen dizilerin sıralı olup olmamasının bir değeri kalmamakla birlikte zaman karmaşıklığımız <code>O(n^2)</code> olacaktır.</p>
<p>Şimdi başka bir taraftan probleme bakalım.Verilen dizileri aynı merge sort işleminde olduğu gibi birleştirelim ve tek bir dizi üzerinden hedef elemana ulaşmaya çalışabiliriz(buda özel bir problem). Bunun sayesinde karmaşıklık <code>O(n)</code> dolaylarına inecektir ve ekstra memory kullanmış olacağız.</p>
<p>Peki çok daha iyi bir çözüm yok mu?</p>
<ol>
<li>Karşılaştırma için <code>diff</code> adında sonsuz değere sahip bir değişken ata</li>
<li>Sıralı olarak verilen diziler üzerinde gezinmek için <code>l</code> ve <code>r</code> adında ki index değişkeni tutun</li>
<li>l = 0 ve r = -1</li>
<li>Döngü şartı l < m ve r >= 0 olmak üzere</li>
<li>Eğer abs(ar1[l] + ar2[r] - sum) < diff ise diff ve result değişkenlerini güncelle</li>
<li>Eğer ar1[l] + ar2[r] < sum ise l++</li>
<li>r--</li>
</ol>
<p>Çözüm aşağıdaki gibi olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">inf</span>
<span class="k">def</span> <span class="nf">print_closest</span><span class="p">(</span><span class="n">ar1</span><span class="p">,</span> <span class="n">ar2</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
<span class="n">diff</span> <span class="o">=</span> <span class="n">inf</span>
<span class="n">res_l</span><span class="p">,</span> <span class="n">res_r</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">l</span><span class="p">,</span> <span class="n">r</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">ar2</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">l</span> <span class="o"><</span> <span class="nb">len</span><span class="p">(</span><span class="n">ar1</span><span class="p">)</span> <span class="ow">and</span> <span class="n">r</span> <span class="o">>=</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">abs</span><span class="p">(</span><span class="n">ar1</span><span class="p">[</span><span class="n">l</span><span class="p">]</span> <span class="o">+</span> <span class="n">ar2</span><span class="p">[</span><span class="n">r</span><span class="p">]</span> <span class="o">-</span> <span class="n">x</span><span class="p">)</span> <span class="o"><</span> <span class="n">diff</span><span class="p">:</span>
<span class="n">resl_l</span><span class="p">,</span> <span class="n">res_r</span><span class="p">,</span> <span class="n">diff</span> <span class="o">=</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">,</span> <span class="nb">abs</span><span class="p">(</span><span class="n">ar1</span><span class="p">[</span><span class="n">l</span><span class="p">]</span> <span class="o">+</span> <span class="n">ar2</span><span class="p">[</span><span class="n">r</span><span class="p">]</span> <span class="o">-</span> <span class="n">x</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ar1</span><span class="p">[</span><span class="n">l</span><span class="p">]</span> <span class="o">+</span> <span class="n">ar2</span><span class="p">[</span><span class="n">r</span><span class="p">]</span> <span class="o">></span> <span class="n">x</span><span class="p">:</span>
<span class="n">r</span> <span class="o">-=</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">l</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"(</span><span class="si">{}</span><span class="s2"> - </span><span class="si">{}</span><span class="s2">)"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">ar1</span><span class="p">[</span><span class="n">res_l</span><span class="p">],</span> <span class="n">ar2</span><span class="p">[</span><span class="n">res_r</span><span class="p">]))</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">ar1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">]</span>
<span class="n">ar2</span> <span class="o">=</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="mi">40</span><span class="p">]</span>
<span class="n">x</span> <span class="o">=</span> <span class="mi">38</span>
<span class="n">print_closest</span><span class="p">(</span><span class="n">ar1</span><span class="p">,</span> <span class="n">ar2</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
</code></pre></div>Bit işlemleri yardımıyla 7 ile çarpma işlemi - Matematik Problemi2015-10-15T18:00:00+02:002015-10-15T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-15:/blog/carp-yedi/<p>Bir sayıyı yedi ile çarpmanın bitwise karşılığı.</p>
<div class="highlight"><pre><span></span><code><span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">num</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">((</span><span class="nv">num</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="mi">3</span><span class="ss">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="nv">num</span><span class="ss">)</span>
</code></pre></div>
<p>Not: Sadece pozitif sayılar için.</p>Prim Algoritması - Greedy Yaklaşımı2015-10-14T18:00:00+02:002015-10-14T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-14:/blog/prim-mst/<p>Tıpkı Kruskal algoritmasında olduğu gibi Prim algoritmasında da amaç en kısa yol ağacını bulmaktır ve greedy yaklaşımı ile çözülür.</p>
<p>Algoritma aşağıdaki şekilde çalışır.</p>
<ol>
<li>Ağaca eklenmiş tüm düğümleri tutacak bir küme oluştur(<code>mst_set</code>).</li>
<li>Başlangıçta tüm düğümlere sonsuz değeri verin sadece içlerinden bir tanesini seçmek için 0 değeri verin.</li>
<li>Eğer <code>1.</code> adımda …</li></ol><p>Tıpkı Kruskal algoritmasında olduğu gibi Prim algoritmasında da amaç en kısa yol ağacını bulmaktır ve greedy yaklaşımı ile çözülür.</p>
<p>Algoritma aşağıdaki şekilde çalışır.</p>
<ol>
<li>Ağaca eklenmiş tüm düğümleri tutacak bir küme oluştur(<code>mst_set</code>).</li>
<li>Başlangıçta tüm düğümlere sonsuz değeri verin sadece içlerinden bir tanesini seçmek için 0 değeri verin.</li>
<li>Eğer <code>1.</code> adımda oluşturduğunuz küme tüm düğümleri kapsamıyorsa<ol>
<li><code>mst_set</code> 'in içermediği ve minimum değere sahip düğümü seçin(<code>u</code>)</li>
<li><code>u</code> 'yu <code>mst_set</code> içerisine atın</li>
<li><code>u</code> 'ya komşu olan tüm düğümlerin değerini güncelleyin.Tüm komşu düğümler(<code>v</code>) üzerinde güncelleme amacıyla gezinirken eğer u-v önceki değerden küçükse değeri u-v şeklinde güncelleyin.</li>
</ol>
</li>
</ol>
<p>Şimdi algoritmayı uygulamaya geçelim.</p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">inf</span>
<span class="k">def</span> <span class="nf">min_key</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">mst_set</span><span class="p">):</span>
<span class="w"> </span><span class="sd">'''Geriye minimum değere sahip komşunun indeksini döndürür'''</span>
<span class="n">mini</span><span class="p">,</span> <span class="n">min_index</span> <span class="o">=</span> <span class="n">inf</span><span class="p">,</span> <span class="n">inf</span>
<span class="k">for</span> <span class="n">index</span><span class="p">,</span> <span class="n">vertex</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">mst_set</span><span class="p">):</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">vertex</span> <span class="ow">and</span> <span class="n">key</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o"><</span> <span class="n">mini</span><span class="p">:</span>
<span class="n">mini</span><span class="p">,</span> <span class="n">min_index</span> <span class="o">=</span> <span class="n">key</span><span class="p">[</span><span class="n">index</span><span class="p">],</span> <span class="n">index</span>
<span class="k">return</span> <span class="n">min_index</span>
<span class="k">def</span> <span class="nf">print_prim</span><span class="p">(</span><span class="n">graph</span><span class="p">):</span>
<span class="c1"># Düğüm sayısı</span>
<span class="n">vertices_len</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span>
<span class="c1"># Oluşturulmuş ağac listesi</span>
<span class="n">parent</span> <span class="o">=</span> <span class="p">[</span><span class="kc">None</span><span class="p">]</span> <span class="o">*</span> <span class="n">vertices_len</span>
<span class="c1"># Minimum ağırlıklı komşuyu seçmek için kullanılan liste</span>
<span class="n">key</span> <span class="o">=</span> <span class="p">[</span><span class="n">inf</span><span class="p">]</span> <span class="o">*</span> <span class="n">vertices_len</span>
<span class="c1"># Ağaca eklenmemiş düğümleri içeren liste</span>
<span class="n">mst_set</span> <span class="o">=</span> <span class="p">[</span><span class="kc">False</span><span class="p">]</span> <span class="o">*</span> <span class="n">vertices_len</span>
<span class="n">key</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span> <span class="c1"># İlk düğüm seçiliyor</span>
<span class="n">parent</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span> <span class="mi">1</span> <span class="c1"># İlk düğüm her zaman root'dur</span>
<span class="k">for</span> <span class="n">count</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">vertices_len</span> <span class="o">-</span> <span class="mi">1</span><span class="p">):</span>
<span class="c1"># Minimum değere sahip komşu</span>
<span class="n">u</span> <span class="o">=</span> <span class="n">min_key</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">mst_set</span><span class="p">)</span>
<span class="c1"># Ağaca eklenmiş olduğu işaretleniyor</span>
<span class="n">mst_set</span><span class="p">[</span><span class="n">u</span><span class="p">]</span> <span class="o">=</span> <span class="kc">True</span>
<span class="c1"># Güncelleme işlemi</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">vertices_len</span><span class="p">):</span>
<span class="k">if</span> <span class="n">graph</span><span class="p">[</span><span class="n">u</span><span class="p">][</span><span class="n">v</span><span class="p">]</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">mst_set</span><span class="p">[</span><span class="n">v</span><span class="p">]</span> <span class="ow">and</span> <span class="n">graph</span><span class="p">[</span><span class="n">u</span><span class="p">][</span><span class="n">v</span><span class="p">]</span> <span class="o"><</span> <span class="n">key</span><span class="p">[</span><span class="n">v</span><span class="p">]:</span>
<span class="n">parent</span><span class="p">[</span><span class="n">v</span><span class="p">],</span> <span class="n">key</span><span class="p">[</span><span class="n">v</span><span class="p">]</span> <span class="o">=</span> <span class="n">u</span><span class="p">,</span> <span class="n">graph</span><span class="p">[</span><span class="n">u</span><span class="p">][</span><span class="n">v</span><span class="p">]</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Edge Weight"</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">vertices_len</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">parent</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="s2">" - "</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="s2">" "</span><span class="p">,</span> <span class="n">graph</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">parent</span><span class="p">[</span><span class="n">i</span><span class="p">]])</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="w"> </span><span class="sd">"""</span>
<span class="sd"> 2 3</span>
<span class="sd"> (0)--(1)--(2)</span>
<span class="sd"> | / \ |</span>
<span class="sd"> 6| 8/ \5 |7</span>
<span class="sd"> | / \ |</span>
<span class="sd"> (3)-------(4)</span>
<span class="sd"> 9</span>
<span class="sd"> """</span>
<span class="n">graph</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">7</span><span class="p">],</span>
<span class="p">[</span><span class="mi">6</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">9</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
<span class="p">]</span>
<span class="n">print_prim</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span>
</code></pre></div>
<p>Algoritmanın zaman karmaşıklığı <code>O(n^2)</code> 'dir. Eğer girdi olarak alınan graf komşuluk matrisi yerine binary heap hardımıyla liste şeklinde kullanılmış olsaydı karmaşıklık <code>O(ElogV)</code> olacaktı.</p>Veri akışının aritmetik ortalaması - Matematik Problemi2015-10-14T18:00:00+02:002015-10-14T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-14:/blog/stream-ortalama/<p>Bu problemde elimize, bir kaynaktan gelen sürekli veriler var yani hep bir sayı akışı var. Bizden her gelen yeni sayı için o anki aritmetik ortalama istenmektedir.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code>Akış ... 10, 20, 30, 40, 50, 60, …
10 geldiğinde ortalama 10.00
20 geldiğinde ortalama 15.00
30 geldiğinde ortalama 20.00
40 …</code></pre></div><p>Bu problemde elimize, bir kaynaktan gelen sürekli veriler var yani hep bir sayı akışı var. Bizden her gelen yeni sayı için o anki aritmetik ortalama istenmektedir.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code>Akış ... 10, 20, 30, 40, 50, 60, …
10 geldiğinde ortalama 10.00
20 geldiğinde ortalama 15.00
30 geldiğinde ortalama 20.00
40 geldiğinde ortalama 25.00
50 geldiğinde ortalama 30.00
60 geldiğinde ortalama 35.00
..................
</code></pre></div>
<p>Çözüm şu şekilde olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">get_avg</span><span class="p">(</span><span class="n">prev</span><span class="p">,</span><span class="w"> </span><span class="n">num</span><span class="p">,</span><span class="w"> </span><span class="n">count</span><span class="p">):</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="n">prev</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">count</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">num</span><span class="p">)</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="p">(</span><span class="n">count</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
<span class="n">def</span><span class="w"> </span><span class="n">calculate_stream</span><span class="p">(</span><span class="n">arr</span><span class="p">):</span>
<span class="w"> </span><span class="n">avg</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="n">enumerate</span><span class="p">(</span><span class="n">arr</span><span class="p">):</span>
<span class="w"> </span><span class="n">avg</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">get_avg</span><span class="p">(</span><span class="n">avg</span><span class="p">,</span><span class="w"> </span><span class="n">num</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="n">num</span><span class="p">,</span><span class="w"> </span><span class="s2">" geldiğinde ortalama = "</span><span class="p">,</span><span class="w"> </span><span class="n">avg</span><span class="p">,</span><span class="w"> </span><span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="p">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">[</span><span class="mi">10</span><span class="p">,</span><span class="w"> </span><span class="mi">20</span><span class="p">,</span><span class="w"> </span><span class="mi">30</span><span class="p">,</span><span class="w"> </span><span class="mi">40</span><span class="p">,</span><span class="w"> </span><span class="mi">50</span><span class="p">,</span><span class="w"> </span><span class="mi">60</span><span class="p">]</span>
<span class="w"> </span><span class="n">calculate_stream</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
</code></pre></div>Bozuk para problemi - Greedy Yaklaşımı2015-10-13T18:00:00+02:002015-10-13T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-13:/blog/bozuk-para/<p>Bize verilen bir miktar para var ve bu miktarı en az sayıda banknot ile karşılamak istiyoruz. Gerçek hayattada sıkça karşılaşılan bir problemi aslında greedy yaklaşımı ile çözüyoruz.</p>
<p>Örneğin</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">V</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">70</span><span class="w"> </span><span class="n">TL</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="mi">50</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">20</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">70</span><span class="w"> </span><span class="n">TL</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">V</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">121</span><span class="w"> </span><span class="n">TL</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">3</span>
<span class="mi">100</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">20</span><span class="w"> </span><span class="n">TL …</span></code></pre></div><p>Bize verilen bir miktar para var ve bu miktarı en az sayıda banknot ile karşılamak istiyoruz. Gerçek hayattada sıkça karşılaşılan bir problemi aslında greedy yaklaşımı ile çözüyoruz.</p>
<p>Örneğin</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">V</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">70</span><span class="w"> </span><span class="n">TL</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="mi">50</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">20</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">70</span><span class="w"> </span><span class="n">TL</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">V</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">121</span><span class="w"> </span><span class="n">TL</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">3</span>
<span class="mi">100</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">20</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">TL</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">121</span><span class="w"> </span><span class="n">TL</span>
</code></pre></div>
<p>Mantık çok basit değil mi? Şimdi çözüme geçelim</p>
<div class="highlight"><pre><span></span><code><span class="nv">MONEY</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">(</span><span class="mi">1</span>,<span class="w"> </span><span class="mi">2</span>,<span class="w"> </span><span class="mi">5</span>,<span class="w"> </span><span class="mi">10</span>,<span class="w"> </span><span class="mi">20</span>,<span class="w"> </span><span class="mi">50</span>,<span class="w"> </span><span class="mi">100</span>,<span class="w"> </span><span class="mi">200</span><span class="ss">)</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">find_min</span><span class="ss">(</span><span class="nv">target</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>[]
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">m</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">sorted</span><span class="ss">(</span><span class="nv">MONEY</span>,<span class="w"> </span><span class="nv">reverse</span><span class="o">=</span><span class="nv">True</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="nv">target</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="nv">m</span>:
<span class="w"> </span><span class="nv">target</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="nv">m</span>
<span class="w"> </span><span class="nb">result</span>.<span class="nv">append</span><span class="ss">(</span><span class="nv">m</span><span class="ss">)</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="o">*</span><span class="nb">result</span>,<span class="w"> </span><span class="nv">sep</span><span class="o">=</span><span class="s2">" Tl + "</span>,<span class="w"> </span><span class="k">end</span><span class="o">=</span><span class="s2">" = {} TL"</span>.<span class="nv">format</span><span class="ss">(</span><span class="nv">sum</span><span class="ss">(</span><span class="nb">result</span><span class="ss">)))</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">target</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1994</span>
<span class="w"> </span><span class="nv">find_min</span><span class="ss">(</span><span class="nv">target</span><span class="ss">)</span>
</code></pre></div>Sayı fibonacci sayısı mı? - Matematik Problemi2015-10-12T18:00:00+02:002015-10-12T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-12:/blog/fibo-kontrol/<p>Verilen sayının fibonacci sayısı olup olmadığını anlamanın basit bir yolu var.</p>
<p>İsterseniz sırayla kendi sayınıza kadar fibonacci sayılarını oluşturup kontrol ederek gidebilirsiniz. Tabi aşırı maliyetli bir çözüm olur, ya da matematikten faydalanırsınız.</p>
<p>Bu çözüme tam kare çözümü denmektedir. Kontrol için aşağıdaki eşitliği kullancağız.</p>
<p><code>(5*n^2 + 4) veya (5*n …</code></p><p>Verilen sayının fibonacci sayısı olup olmadığını anlamanın basit bir yolu var.</p>
<p>İsterseniz sırayla kendi sayınıza kadar fibonacci sayılarını oluşturup kontrol ederek gidebilirsiniz. Tabi aşırı maliyetli bir çözüm olur, ya da matematikten faydalanırsınız.</p>
<p>Bu çözüme tam kare çözümü denmektedir. Kontrol için aşağıdaki eşitliği kullancağız.</p>
<p><code>(5*n^2 + 4) veya (5*n^2 – 4)</code></p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">is_perfect_square</span><span class="ss">(</span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">s</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">**</span><span class="w"> </span><span class="mi">0</span>.<span class="mi">5</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">s</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">s</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nv">x</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">is_fibo</span><span class="ss">(</span><span class="nv">n</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">is_perfect_square</span><span class="ss">(</span><span class="mi">5</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">4</span><span class="ss">)</span><span class="w"> </span><span class="nv">or</span><span class="w"> </span><span class="nv">is_perfect_square</span><span class="ss">(</span><span class="mi">5</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">4</span><span class="ss">)</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">34</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">is_fibo</span><span class="ss">(</span><span class="nv">number</span><span class="ss">))</span>
</code></pre></div>Çarpma ve bölme işlemi kullanmadan üs alma - Matematik Problemi2015-10-12T18:00:00+02:002015-10-12T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-12:/blog/pow-without/<p>Üs alma işlemi problemlerine farklı bir yaklaşım sunan bu problemde, çarpma(<code>*</code>) ve bölme(<code>/</code>) işlemi kullanmadan üs alma işlemine bakacağız.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="mf">5</span><span class="o">^</span><span class="mf">6</span><span class="w"> </span><span class="n">işlemi</span><span class="w"> </span><span class="n">için</span><span class="p">;</span>
<span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">0</span>
<span class="mf">1.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">2</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">25</span>
<span class="mf">2.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">25</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">3</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">125</span>
<span class="mf">3.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">125</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">4</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">625 …</span></code></pre></div><p>Üs alma işlemi problemlerine farklı bir yaklaşım sunan bu problemde, çarpma(<code>*</code>) ve bölme(<code>/</code>) işlemi kullanmadan üs alma işlemine bakacağız.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="mf">5</span><span class="o">^</span><span class="mf">6</span><span class="w"> </span><span class="n">işlemi</span><span class="w"> </span><span class="n">için</span><span class="p">;</span>
<span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">0</span>
<span class="mf">1.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">2</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">25</span>
<span class="mf">2.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">25</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">3</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">125</span>
<span class="mf">3.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">125</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">4</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">625</span>
<span class="mf">4.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">625</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">5</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">3125</span>
<span class="mf">5.</span><span class="p">)</span><span class="w"> </span><span class="mf">5</span><span class="w"> </span><span class="n">kere</span><span class="w"> </span><span class="mf">3125</span><span class="w"> </span><span class="n">ekle</span><span class="w"> </span><span class="p">(</span><span class="mf">5</span><span class="o">^</span><span class="mf">6</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">15625</span>
</code></pre></div>
<h3>İç içe döngü kullanarak</h3>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">nested_pow</span><span class="ss">(</span><span class="nv">a</span>,<span class="w"> </span><span class="nv">b</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="nb">result</span>,<span class="w"> </span><span class="nv">increment</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">a</span>,<span class="w"> </span><span class="nv">a</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">range</span><span class="ss">(</span><span class="mi">1</span>,<span class="w"> </span><span class="nv">b</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">j</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">range</span><span class="ss">(</span><span class="mi">1</span>,<span class="w"> </span><span class="nv">a</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="nv">increment</span>
<span class="w"> </span><span class="nv">increment</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">result</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">result</span>
</code></pre></div>
<h3>Recursive çözüm</h3>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">recursion_pow</span><span class="ss">(</span><span class="nv">a</span>,<span class="w"> </span><span class="nv">b</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">a</span>,<span class="w"> </span><span class="nv">recursion_pow</span><span class="ss">(</span><span class="nv">a</span>,<span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="ss">))</span>
<span class="w"> </span><span class="k">else</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span>
<span class="nv">def</span><span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">x</span>,<span class="w"> </span><span class="nv">y</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">y</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">multiply</span><span class="ss">(</span><span class="nv">x</span>,<span class="w"> </span><span class="nv">y</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="ss">)</span>
<span class="w"> </span><span class="k">else</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span>
</code></pre></div>
<div class="highlight"><pre><span></span><code><span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">nested_pow</span><span class="ss">(</span><span class="mi">5</span>,<span class="w"> </span><span class="mi">6</span><span class="ss">))</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">recursion_pow</span><span class="ss">(</span><span class="mi">5</span>,<span class="w"> </span><span class="mi">3</span><span class="ss">))</span>
</code></pre></div>Kruskal Algoritması - Greedy Yaklaşımı2015-10-11T18:00:00+02:002015-10-11T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-11:/blog/kuruskal-mst/<p>En küçük yol ağacı problemine(minimum spanning tree) üretilmiş bir çözümdür. En basit graf algoritmalarından biridir. Greedy yaklaşımı ile çözüme ulaşılır. Amaç bir graf içerisinde tüm düğümleri kapsayan minimum maliyete sahip ağacı elde etmektir.</p>
<p>Aşağıda kabaca algoritmanın çalışmasını anlayabilirsiniz.</p>
<ol>
<li>Tüm kenarları maliyetlerine göre küçükten büyüğe doğru sıralay</li>
<li>En düşük maliyetli …</li></ol><p>En küçük yol ağacı problemine(minimum spanning tree) üretilmiş bir çözümdür. En basit graf algoritmalarından biridir. Greedy yaklaşımı ile çözüme ulaşılır. Amaç bir graf içerisinde tüm düğümleri kapsayan minimum maliyete sahip ağacı elde etmektir.</p>
<p>Aşağıda kabaca algoritmanın çalışmasını anlayabilirsiniz.</p>
<ol>
<li>Tüm kenarları maliyetlerine göre küçükten büyüğe doğru sıralay</li>
<li>En düşük maliyetli kenarı seçin ve oluşturduğunuz ağaçta çevrim oluşturup oluşturmadığını kontrol edin.Eğer içermiyorsa kenarı ağaca ekleyin.<ol>
<li>adımı işlem tamamlanana kadar devam ettirin.</li>
</ol>
</li>
</ol>
<p>Minimum spanning tree <code>(V-1)</code> adet kenar içerecektir.</p>
<p>Çevrim oluşturmak ne demektir? Eğer başladığınız bir noktadan dönüp dolaşıp ağaç üzerinde tekrar aynı noktaya gelebiliyorsanız çevrim oluşmuş demektir. Çevrim olup olmadığının anlanması özel bir konudur. Bununla ilgili yazılarımı ilerleyen zamanlarda yazacağım. <code>Union-Find</code> algoritması kullanılır.Mantık olarak çok basittir.</p>
<p>Çözüm aşağıdaki gibi olur</p>
<div class="highlight"><pre><span></span><code><span class="n">parent</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">dict</span><span class="p">()</span>
<span class="nf">rank</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">dict</span><span class="p">()</span>
<span class="n">def</span><span class="w"> </span><span class="n">make_set</span><span class="p">(</span><span class="n">vertice</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">parent</span><span class="o">[</span><span class="n">vertice</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">vertice</span>
<span class="w"> </span><span class="nf">rank</span><span class="o">[</span><span class="n">vertice</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
<span class="n">def</span><span class="w"> </span><span class="n">find</span><span class="p">(</span><span class="n">vertice</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">parent</span><span class="o">[</span><span class="n">vertice</span><span class="o">]</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="nl">vertice</span><span class="p">:</span>
<span class="w"> </span><span class="n">parent</span><span class="o">[</span><span class="n">vertice</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">find</span><span class="p">(</span><span class="n">parent</span><span class="o">[</span><span class="n">vertice</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">parent</span><span class="o">[</span><span class="n">vertice</span><span class="o">]</span>
<span class="n">def</span><span class="w"> </span><span class="ow">union</span><span class="p">(</span><span class="n">vertice1</span><span class="p">,</span><span class="w"> </span><span class="n">vertice2</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">root1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">find</span><span class="p">(</span><span class="n">vertice1</span><span class="p">)</span>
<span class="w"> </span><span class="n">root2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">find</span><span class="p">(</span><span class="n">vertice2</span><span class="p">)</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">root1</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="nl">root2</span><span class="p">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nf">rank</span><span class="o">[</span><span class="n">root1</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="nf">rank</span><span class="o">[</span><span class="n">root2</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">parent</span><span class="o">[</span><span class="n">root2</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">root1</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="n">parent</span><span class="o">[</span><span class="n">root1</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">root2</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nf">rank</span><span class="o">[</span><span class="n">root1</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nf">rank</span><span class="o">[</span><span class="n">root2</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="nf">rank</span><span class="o">[</span><span class="n">root2</span><span class="o">]</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="n">def</span><span class="w"> </span><span class="n">get_sorted_edges</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="s1">'Kenarları elde edelim'</span>
<span class="w"> </span><span class="n">edges</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="err">[]</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">src</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="nl">graph</span><span class="p">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">dest</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="n">graph</span><span class="o">[</span><span class="n">src</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">edges</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">tuple</span><span class="p">(</span><span class="n">src</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">dest</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">sorted</span><span class="p">(</span><span class="n">edges</span><span class="p">,</span><span class="w"> </span><span class="k">key</span><span class="o">=</span><span class="n">lambda</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span><span class="w"> </span><span class="n">x</span><span class="o">[</span><span class="n">2</span><span class="o">]</span><span class="p">)</span>
<span class="n">def</span><span class="w"> </span><span class="n">print_kruskal</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">vertex</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="nl">graph</span><span class="p">:</span>
<span class="w"> </span><span class="n">make_set</span><span class="p">(</span><span class="n">vertex</span><span class="p">)</span>
<span class="w"> </span><span class="n">sorted_edges</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">get_sorted_edges</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">edge</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="nl">sorted_edges</span><span class="p">:</span>
<span class="w"> </span><span class="n">v1</span><span class="p">,</span><span class="w"> </span><span class="n">v2</span><span class="p">,</span><span class="w"> </span><span class="n">w</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">edge</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">find</span><span class="p">(</span><span class="n">v1</span><span class="p">)</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">find</span><span class="p">(</span><span class="n">v2</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="ow">union</span><span class="p">(</span><span class="n">v1</span><span class="p">,</span><span class="w"> </span><span class="n">v2</span><span class="p">)</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">edge</span><span class="p">)</span><span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">sonuc</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="ss">"""</span>
<span class="ss"> 10</span>
<span class="ss"> 0--------1</span>
<span class="ss"> | \ |</span>
<span class="ss"> 6| 5\ |15</span>
<span class="ss"> | \ |</span>
<span class="ss"> 2--------3</span>
<span class="ss"> 4</span>
<span class="ss"> Vertices = 0,1,2,3</span>
<span class="ss"> """</span>
<span class="w"> </span><span class="n">graph</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="err">{</span><span class="ss">"0"</span><span class="err">:</span><span class="w"> </span><span class="o">[</span><span class="n">("1", 10), ("2", 6), ("3", 5)</span><span class="o">]</span><span class="p">,</span>
<span class="w"> </span><span class="ss">"1"</span><span class="err">:</span><span class="w"> </span><span class="o">[</span><span class="n">("3", 15)</span><span class="o">]</span><span class="p">,</span>
<span class="w"> </span><span class="ss">"2"</span><span class="err">:</span><span class="w"> </span><span class="o">[</span><span class="n">("3", 4)</span><span class="o">]</span><span class="p">,</span>
<span class="w"> </span><span class="ss">"3"</span><span class="err">:</span><span class="w"> </span><span class="err">[]}</span>
<span class="w"> </span><span class="n">print_kruskal</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span>
</code></pre></div>
<p>Bu algoritmanın zaman karmaşası <code>O(ElogE)</code> veya <code>O(ElogV)</code> olur.</p>En basit hali ile text arama işlemi - String Algoritmaları2015-10-11T18:00:00+02:002015-10-11T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-11:/blog/naive-search-string/<p>Text işlemlerinde, bir dizgi içerisinde dizgi aramadaki en basit çözümü inceleyeceğiz.</p>
<div class="highlight"><pre><span></span><code>txt[] = "THIS IS A TEST TEXT"
pat[] = "TEST"
Output: 10
</code></pre></div>
<div class="highlight"><pre><span></span><code>txt[] = "AABAACAADAABAAABAA"
pat[] = "AABA"
Output: 0,9,13
</code></pre></div>
<p>Çözüm aşağıdaki gibi olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="k">search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">m</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">),</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="nc">text</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1 …</span></code></pre></div><p>Text işlemlerinde, bir dizgi içerisinde dizgi aramadaki en basit çözümü inceleyeceğiz.</p>
<div class="highlight"><pre><span></span><code>txt[] = "THIS IS A TEST TEXT"
pat[] = "TEST"
Output: 10
</code></pre></div>
<div class="highlight"><pre><span></span><code>txt[] = "AABAACAADAABAAABAA"
pat[] = "AABA"
Output: 0,9,13
</code></pre></div>
<p>Çözüm aşağıdaki gibi olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="k">search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">m</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">),</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="nc">text</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">m</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nc">text</span><span class="o">[</span><span class="n">i + j</span><span class="o">]</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">pattern</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="k">break</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nl">m</span><span class="p">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">txt</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"AABAACAADAABAAABAA"</span>
<span class="w"> </span><span class="n">pat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"AABA"</span>
<span class="w"> </span><span class="k">search</span><span class="p">(</span><span class="n">txt</span><span class="p">,</span><span class="w"> </span><span class="n">pat</span><span class="p">)</span>
</code></pre></div>
<h3>En iyi durum nedir?</h3>
<div class="highlight"><pre><span></span><code>txt[] = "AABCCAADDEE"
pat[] = "FAA"
</code></pre></div>
<p>Desenin ilk karakteri arana text içerisinde bulunmadığı zamandır ve karmaşıklık <code>O(n)</code> olur.</p>
<h3>En kötü durum nedir?</h3>
<div class="highlight"><pre><span></span><code>txt[] = "AAAAAAAAAAAAAAAAAA"
pat[] = "AAAAA"
</code></pre></div>
<p>Yani tüm karakterler aynı olduğunda ve</p>
<div class="highlight"><pre><span></span><code>txt[] = "AAAAAAAAAAAAAAAAAB"
pat[] = "AAAAB"
</code></pre></div>
<p>son karakterler aynı olursa. Bu durumda da karmaşıklık <code>O(m*(n-m+1))</code> olur.</p>
<p>String arama işlemlerinin önemli olduğunu söylemiştim. Bu gördüğünüz algoritma adı üstünde en kaba,basit çözümdür. Çok daha efektif algoritmalar bulunmaktadır.</p>İş planlama problemi - Greedy Yaklaşımı2015-10-11T12:00:00+02:002015-10-11T12:00:00+02:00Buraktag:www.koseburak.net,2015-10-11:/blog/is-planlama/<p>İş planlanması ile ilgili olan bir problem. Girdi olarak son teslim tarihine ve kazanç bilgilerine sahip olan işler veriliyor. En büyük kazancı nasıl elde edebileceğimizi bulmamız gerekiyor.</p>
<p>Örnek olarak ;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span>
<span class="w"> </span><span class="n">JobID</span><span class="w"> </span><span class="n">Son</span><span class="w"> </span><span class="n">Tarih</span><span class="w"> </span><span class="n">Kazanç</span>
<span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="mi">4</span><span class="w"> </span><span class="mi">20</span><span class="w"> </span>
<span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">10</span>
<span class="w"> </span><span class="n">c</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">40</span><span class="w"> </span>
<span class="w"> </span><span class="n">d</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">30</span>
<span class="n">Output</span><span class="o">:</span>
<span class="w"> </span><span class="n">c</span><span class="o">,</span><span class="w"> </span><span class="n">a</span><span class="w"> </span>
<span class="n">Input …</span></code></pre></div><p>İş planlanması ile ilgili olan bir problem. Girdi olarak son teslim tarihine ve kazanç bilgilerine sahip olan işler veriliyor. En büyük kazancı nasıl elde edebileceğimizi bulmamız gerekiyor.</p>
<p>Örnek olarak ;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span>
<span class="w"> </span><span class="n">JobID</span><span class="w"> </span><span class="n">Son</span><span class="w"> </span><span class="n">Tarih</span><span class="w"> </span><span class="n">Kazanç</span>
<span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="mi">4</span><span class="w"> </span><span class="mi">20</span><span class="w"> </span>
<span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">10</span>
<span class="w"> </span><span class="n">c</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">40</span><span class="w"> </span>
<span class="w"> </span><span class="n">d</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">30</span>
<span class="n">Output</span><span class="o">:</span>
<span class="w"> </span><span class="n">c</span><span class="o">,</span><span class="w"> </span><span class="n">a</span><span class="w"> </span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span>
<span class="w"> </span><span class="n">JobID</span><span class="w"> </span><span class="n">Son</span><span class="w"> </span><span class="n">Tarih</span><span class="w"> </span><span class="n">Kazanç</span>
<span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="mi">100</span>
<span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">19</span>
<span class="w"> </span><span class="n">c</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="mi">27</span>
<span class="w"> </span><span class="n">d</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="mi">25</span>
<span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="mi">15</span>
<span class="n">Output</span><span class="o">:</span>
<span class="w"> </span><span class="n">c</span><span class="o">,</span><span class="w"> </span><span class="n">a</span><span class="o">,</span><span class="w"> </span><span class="n">e</span>
</code></pre></div>
<p>Greedy yaklaşımı ile şu şekilde çözebiliriz.</p>
<ol>
<li>Tüm işleri azalan kazanç oranlarına göre sırala</li>
<li>İlk iş başlangıcın olsun</li>
<li>Geriye kalan n-1 iş için<ol>
<li>Eğer şuanki iş zaman aşımına uğramadan sonuç listesine sığabiliyorsa elindeki işi sonuç dizisine ekle, aksi halde şuanki işi es geç.</li>
</ol>
</li>
</ol>
<p>Çözüm aşağıdaki gibi olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">print_job_scheduling</span><span class="p">(</span><span class="n">jobs</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">jobs</span><span class="p">.</span><span class="n">sort</span><span class="p">(</span><span class="k">key</span><span class="o">=</span><span class="n">lambda</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span><span class="w"> </span><span class="n">x</span><span class="o">[</span><span class="n">2</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="nf">reverse</span><span class="o">=</span><span class="k">True</span><span class="p">)</span>
<span class="w"> </span><span class="k">result</span><span class="p">,</span><span class="w"> </span><span class="n">slot</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">None</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">jobs</span><span class="p">),</span><span class="w"> </span><span class="o">[</span><span class="n">False</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">jobs</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">job</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="nl">jobs</span><span class="p">:</span>
<span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">min</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">jobs</span><span class="p">),</span><span class="w"> </span><span class="n">job</span><span class="o">[</span><span class="n">1</span><span class="o">]</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="ow">not</span><span class="w"> </span><span class="n">slot</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="k">result</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">job</span><span class="o">[</span><span class="n">0</span><span class="o">]</span>
<span class="w"> </span><span class="n">slot</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">True</span>
<span class="w"> </span><span class="k">break</span>
<span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="k">result</span><span class="p">,</span><span class="w"> </span><span class="n">sep</span><span class="o">=</span><span class="s1">'\n'</span><span class="p">)</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="p">(</span><span class="n">id</span><span class="p">,</span><span class="n">zaman</span><span class="w"> </span><span class="n">aşımı</span><span class="p">,</span><span class="n">kazanç</span><span class="p">)</span>
<span class="w"> </span><span class="n">jobs</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">('a', 2, 100), ('b', 1, 19),</span>
<span class="n"> ('c', 2, 27), ('d', 1, 25), ('e', 3, 15)</span><span class="o">]</span>
<span class="w"> </span><span class="n">print_job_scheduling</span><span class="p">(</span><span class="n">jobs</span><span class="p">)</span>
</code></pre></div>
<p>Bu algoritmanın zaman karmaşıklığı <code>O(n^2)</code> olacaktır.Union-find veri yapısı kullanılarak <code>O(n)</code> gibi bir karmaşıklıkta çözülebilir.</p>Etkinlik paylaşım problemi - Greedy Yaklaşımı2015-10-11T10:00:00+02:002015-10-11T10:00:00+02:00Buraktag:www.koseburak.net,2015-10-11:/blog/etkinlik-secim-problemi/<p>Etkinlik paylaşım problemi klasik bir açgözlü(greedy) yaklaşımı ile çözülen bir problemdir.Greedy kısaca parça parça çözüme ulaşılan ve her bir aşamada o anki en optimum seçeneği seçemedir.</p>
<p>Eğer bir problemi Greedy yaklaşımı ile çözebiliyorsak muhtemelen o problemin çözümü diğer çözüm yöntemlerine göre en optimum çözüm olacaktır fakat her durumda …</p><p>Etkinlik paylaşım problemi klasik bir açgözlü(greedy) yaklaşımı ile çözülen bir problemdir.Greedy kısaca parça parça çözüme ulaşılan ve her bir aşamada o anki en optimum seçeneği seçemedir.</p>
<p>Eğer bir problemi Greedy yaklaşımı ile çözebiliyorsak muhtemelen o problemin çözümü diğer çözüm yöntemlerine göre en optimum çözüm olacaktır fakat her durumda uygulanamaz.</p>
<p>Şimdi probleme gelelim, size n adet aktivite ve her aktivitenin başlangıç ve bitiş süreleri veriliyor.Sizden tek bir kişinin yapabileceği en fazla sayıda aktivite gerçekleştirmesi isteniyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code>etkinlikler = 0 1 2 3 4 5
- - - - - - - - - - - -
başlangıç[] = {1, 3, 0, 5, 8, 5};
bitiş[] = {2, 4, 6, 7, 9, 9};
Cevap = {0,1,3,4}
</code></pre></div>
<p>İlk bitecek aktiviteleri aradan çıkarırsak sonuca ulaşabiliriz.Bunun için yapılması gerekenler;</p>
<ol>
<li>Aktiviteleri bitiş zamanlarına göre sıralamalıyız</li>
<li>Sıralanmış aktivitelerden ilkini almalıyız.</li>
<li>Geriye kalan aktivitelerin başlangıç zamanı ile seçilen aktivitenin bitiş zamanı karşılaştırılmalı</li>
</ol>
<p>Çözüme ait kod aşağıdaki gibi olur.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">print_max_activities</span><span class="ss">(</span><span class="nv">activities</span><span class="ss">)</span>:
<span class="w"> </span><span class="nv">choise</span>,<span class="nv">activities</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">activities</span>[<span class="mi">0</span>],<span class="nv">activities</span>[<span class="mi">1</span>:]
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">choise</span><span class="ss">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">activities</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">i</span>[<span class="mi">0</span>]<span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="nv">choise</span>[<span class="mi">1</span>]:
<span class="w"> </span><span class="nv">choise</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">i</span>
<span class="w"> </span><span class="nv">print</span><span class="ss">(</span><span class="nv">choise</span><span class="ss">)</span>
<span class="k">if</span><span class="w"> </span><span class="nv">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span>:
<span class="w"> </span>#[<span class="ss">(</span><span class="nv">start</span>,<span class="nv">finish</span><span class="ss">)</span>]
<span class="w"> </span><span class="nv">activities</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>[<span class="ss">(</span><span class="mi">1</span>,<span class="mi">2</span><span class="ss">)</span>,<span class="ss">(</span><span class="mi">3</span>,<span class="mi">4</span><span class="ss">)</span>,<span class="ss">(</span><span class="mi">0</span>,<span class="mi">6</span><span class="ss">)</span>,<span class="ss">(</span><span class="mi">5</span>,<span class="mi">7</span><span class="ss">)</span>,<span class="ss">(</span><span class="mi">8</span>,<span class="mi">9</span><span class="ss">)</span>,<span class="ss">(</span><span class="mi">5</span>,<span class="mi">9</span><span class="ss">)</span>]
<span class="w"> </span><span class="nv">activities</span>.<span class="nv">sort</span><span class="ss">(</span><span class="nv">key</span><span class="o">=</span><span class="nv">lambda</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span>:<span class="w"> </span><span class="nv">x</span>[<span class="mi">1</span>]<span class="ss">)</span><span class="w"> </span>#<span class="nv">Biti</span>ş<span class="nv">e</span><span class="w"> </span><span class="nv">g</span>ö<span class="nv">re</span><span class="w"> </span><span class="nv">sıralama</span>
<span class="w"> </span><span class="nv">print_max_activities</span><span class="ss">(</span><span class="nv">activities</span><span class="ss">)</span>
</code></pre></div>Üs alma işlemi (a^x) - Divide and Conquer2015-10-11T08:00:00+02:002015-10-11T08:00:00+02:00Buraktag:www.koseburak.net,2015-10-11:/blog/pow-daq/<p>Üs alma işlemi kullanılan programlama dilinin standart olarak verdiği işlemler ile gayet kolay olarak yapılabilen bir işlemdir.En basit hali ile çözüm şu şekildedir.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">brute</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">range</span><span class="ss">(</span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="nv">num</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">result</span>
</code></pre></div>
<p>Bu çözüm iteratif olarak yazılmış ve <code>O(n)</code> karmaşıklığına sahip hoş …</p><p>Üs alma işlemi kullanılan programlama dilinin standart olarak verdiği işlemler ile gayet kolay olarak yapılabilen bir işlemdir.En basit hali ile çözüm şu şekildedir.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">brute</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">range</span><span class="ss">(</span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="nb">result</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="nv">num</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">result</span>
</code></pre></div>
<p>Bu çözüm iteratif olarak yazılmış ve <code>O(n)</code> karmaşıklığına sahip hoş olmayan bir çözümdür. Şimdi bu çözümü <code>Divide and Conquer</code> mantığına uygun bir çözüm ile yazalım.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="nv">elif</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span>
<span class="w"> </span><span class="k">else</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">num</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span>
</code></pre></div>
<p>Çözümü divide and conquer mantığına göre çözsekte karmaşıklıkta hala değişiklik olmadı ve zaman karmaşıklığımız <code>O(n)</code>. Biraz dikkat ederseniz gereksiz tekrarlar olduğunu fark edebilirsiniz. Bunları önlemek için aşağıdaki gibi bir yol izleyebiliriz.</p>
<div class="highlight"><pre><span></span><code><span class="nv">def</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="ss">)</span>:
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="nv">temp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">div_conq</span><span class="ss">(</span><span class="nv">num</span>,<span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="mi">2</span><span class="ss">)</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">temp</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">temp</span>
<span class="w"> </span><span class="k">else</span>:
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nv">num</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">temp</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">temp</span>
</code></pre></div>
<p>Artık karmaşıklığımız <code>O(logn)</code> olmuştur. Fakat yazdığımız kod negatif sayısal için çalışmayacaktır. Ufak bir ekleme ile şu hale getirebilriz.</p>
<div class="highlight"><pre><span></span><code><span class="nt">def</span><span class="w"> </span><span class="nt">div_conq</span><span class="o">(</span><span class="nt">num</span><span class="o">,</span><span class="w"> </span><span class="nt">x</span><span class="o">):</span>
<span class="w"> </span><span class="nt">if</span><span class="w"> </span><span class="nt">x</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nt">0</span><span class="o">:</span>
<span class="w"> </span><span class="nt">return</span><span class="w"> </span><span class="nt">1</span>
<span class="w"> </span><span class="nt">temp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nt">div_conq</span><span class="o">(</span><span class="nt">num</span><span class="o">,</span><span class="w"> </span><span class="nt">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="nt">2</span><span class="o">)</span>
<span class="w"> </span><span class="nt">if</span><span class="w"> </span><span class="nt">x</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="nt">2</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nt">0</span><span class="o">:</span>
<span class="w"> </span><span class="nt">return</span><span class="w"> </span><span class="nt">temp</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nt">temp</span>
<span class="w"> </span><span class="nt">else</span><span class="o">:</span>
<span class="w"> </span><span class="nt">if</span><span class="o">(</span><span class="nt">x</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="nt">0</span><span class="o">):</span>
<span class="w"> </span><span class="nt">return</span><span class="w"> </span><span class="nt">num</span><span class="o">*</span><span class="nt">temp</span><span class="o">*</span><span class="nt">temp</span><span class="o">;</span>
<span class="w"> </span><span class="nt">else</span><span class="o">:</span>
<span class="w"> </span><span class="nt">return</span><span class="w"> </span><span class="o">(</span><span class="nt">temp</span><span class="o">*</span><span class="nt">temp</span><span class="o">)/</span><span class="nt">num</span><span class="o">;</span>
</code></pre></div>Neredeyse sıralı dizi içerisinde arama - Arama Algoritması2015-10-10T18:00:00+02:002015-10-10T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-10:/blog/almost-sorted-search/<p>Ufak bir işlem sonrası sıralanmış dizinin bazı elemanlarının yerleri karıştırılıyor. Örneğin <code>i.</code> pozisyonda olması gereken eleman <code>i-1</code> ya da <code>i+1</code> pozisyonunda bulunuyor. Hedef olarak verilen sayının dizi içerisindeki pozisyonunun bulunması amaçlanıyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">40</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">50</span><span class="o">,</span><span class="w"> </span><span class="mi">80</span><span class="o">,</span><span class="w"> </span><span class="mi">70</span><span class="o">},</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">40</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">3 …</span></code></pre></div><p>Ufak bir işlem sonrası sıralanmış dizinin bazı elemanlarının yerleri karıştırılıyor. Örneğin <code>i.</code> pozisyonda olması gereken eleman <code>i-1</code> ya da <code>i+1</code> pozisyonunda bulunuyor. Hedef olarak verilen sayının dizi içerisindeki pozisyonunun bulunması amaçlanıyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">40</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">50</span><span class="o">,</span><span class="w"> </span><span class="mi">80</span><span class="o">,</span><span class="w"> </span><span class="mi">70</span><span class="o">},</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">40</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">2</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">40</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">50</span><span class="o">,</span><span class="w"> </span><span class="mi">80</span><span class="o">,</span><span class="w"> </span><span class="mi">70</span><span class="o">},</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">90</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span>
</code></pre></div>
<p>Klasik olarak en ilkel çözüm, tüm diziyi boydan boya aramaktır. <code>O(n)</code> karmaşıklığa sahiptir.</p>
<p>Bu çözümde ise sıralı diziler üzerinde uygulanan algoritmalardan olan <code>binary search</code> algoritmasının biraz daha modifiye edilmiş halini kullanacağız.</p>
<p>Fikir olarak şuna dayanmaktadır; elimizdeki değeri ortandaki üç eleman ile karşılaştıracağız. Geri mantık <code>binary search</code> algoritması gibidir.</p>
<p>Çözüm aşağıdadır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">mod_binary_search</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="s1">'''Modifiye edilmiş binary search'''</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="nl">l</span><span class="p">:</span>
<span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="p">(</span><span class="n">r</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">l</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">orta</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="n">eleman</span><span class="w"> </span><span class="n">ile</span><span class="w"> </span><span class="n">karşılaştırma</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">mid</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid - 1</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid + 1</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Eğer</span><span class="w"> </span><span class="n">eleman</span><span class="w"> </span><span class="n">ortancadan</span><span class="w"> </span><span class="n">küçükse</span><span class="p">,</span><span class="w"> </span><span class="n">sola</span><span class="w"> </span><span class="n">doğru</span><span class="w"> </span><span class="n">kaydır</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">mod_binary_search</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Aksi</span><span class="w"> </span><span class="n">halde</span><span class="w"> </span><span class="n">sağa</span><span class="w"> </span><span class="n">doğru</span><span class="w"> </span><span class="n">kaydır</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">mod_binary_search</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Bulunamadı</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">3, 2, 10, 4, 40</span><span class="o">]</span>
<span class="w"> </span><span class="n">target</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span>
<span class="w"> </span><span class="k">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">mod_binary_search</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">target</span><span class="p">)</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="k">result</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="k">result</span><span class="p">)</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="ss">"bulunamadi"</span><span class="p">)</span>
</code></pre></div>
<p>Algoritmanın karmaşıklığı <code>O(logn)</code> olur.</p>Girilen sayıdan bir sonraki büyük sayıyı bulma - Matematik Problemi2015-10-08T18:00:00+02:002015-10-08T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-08:/blog/next-num/<p>String olarak verilen sayının bir sonraki büyük saıyı ekrana bastıran, eğer şartlar uygun değilse imkansız yazan problemi inceleyeceğiz.</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"218765"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"251678"</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"1234"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"1243"</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"4321"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"Imkansız"</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"534976"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"536479"</span>
</code></pre></div>
<p>Çözüm için;</p>
<ol>
<li>Eğer tüm sayılar azalan sırada ise 'Imkansız' basılır.</li>
<li>Eğer tüm …</li></ol><p>String olarak verilen sayının bir sonraki büyük saıyı ekrana bastıran, eğer şartlar uygun değilse imkansız yazan problemi inceleyeceğiz.</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"218765"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"251678"</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"1234"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"1243"</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"4321"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"Imkansız"</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"534976"</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="s2">"536479"</span>
</code></pre></div>
<p>Çözüm için;</p>
<ol>
<li>Eğer tüm sayılar azalan sırada ise 'Imkansız' basılır.</li>
<li>Eğer tüm sayılar artan sırada ise son iki sayı ver değiştirecektir.</li>
<li>Diğer sayılar için<ol>
<li>Sayının birler basamağından başlanarak diğer haneleri incelenir. Birber basamağından daha değerli basamaklara doğru artışı bozacak hane aranır. Örneğin “534976” sayısı için <code>4</code> olan basamak bu durumu sağlar.(6<7<9)</li>
<li>Sayı 53,4,976 şeklinde bölünür ve 4'ün sağ tarafında kalan sayılardan 4'den büyük olan en küçük sayı bulunur(6'dır).</li>
<li>4 ve 6 yer değişir("53,6,974" olur).</li>
<li>"974" olan kısım sıralanır ve son olarak cevap "536479" olur.</li>
</ol>
</li>
</ol>
<p>Çözüm aşağıdaki gibi olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">find_next</span><span class="p">(</span><span class="n">num</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">num</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">i - 1</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="k">break</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="ss">"Imkansiz"</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span>
<span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">smallest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">i - 1</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">i</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">num</span><span class="p">))</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">smallest</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">smallest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">j</span>
<span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">list</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
<span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">smallest</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">i - 1</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">i - 1</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">smallest</span><span class="o">]</span>
<span class="w"> </span><span class="n">num</span><span class="o">[</span><span class="n">i:</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">sorted</span><span class="p">(</span><span class="n">num</span><span class="o">[</span><span class="n">i:</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="s1">''</span><span class="p">.</span><span class="k">join</span><span class="p">(</span><span class="n">num</span><span class="p">))</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">find_next</span><span class="p">(</span><span class="ss">"534976"</span><span class="p">)</span>
<span class="w"> </span><span class="n">find_next</span><span class="p">(</span><span class="ss">"4321"</span><span class="p">)</span>
</code></pre></div>KMP Algoritmasi - String Algoritmaları2015-10-07T18:00:00+02:002015-10-07T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-07:/blog/kmp/<p>Bir diğer string arama algoritmalarından olan <code>KMP</code> algoritmasına bakacağız.</p>
<p>Örnek olarak;</p>
<div class="highlight"><pre><span></span><code>txt = "THIS IS A TEST TEXT"
pat = "TEST"
Output : 10
</code></pre></div>
<p>ve</p>
<div class="highlight"><pre><span></span><code>txt = "AABAACAADAABAAABAA"
pat = "AABA"
Output : 0, 9, 13
</code></pre></div>
<p>Bir önceki <a href="https://www.koseburak.net/blog/naive-search-string/">yazıda</a> en kaba hali ile bir text içerisinde nasıl başka bir text aramasının yapılacağını incelemiştik. O algoritma <code>O …</code></p><p>Bir diğer string arama algoritmalarından olan <code>KMP</code> algoritmasına bakacağız.</p>
<p>Örnek olarak;</p>
<div class="highlight"><pre><span></span><code>txt = "THIS IS A TEST TEXT"
pat = "TEST"
Output : 10
</code></pre></div>
<p>ve</p>
<div class="highlight"><pre><span></span><code>txt = "AABAACAADAABAAABAA"
pat = "AABA"
Output : 0, 9, 13
</code></pre></div>
<p>Bir önceki <a href="https://www.koseburak.net/blog/naive-search-string/">yazıda</a> en kaba hali ile bir text içerisinde nasıl başka bir text aramasının yapılacağını incelemiştik. O algoritma <code>O(m*(n-m+1))</code> karmaşıklığa sahipti. Bu algoritmanın en kötü durumda karmaşıklığı <code>O(n)</code>'dir.</p>
<h3>KMP (Knuth Morris Pratt)</h3>
<p>Kısaca yapılan iş şu şekilde yürümektedir. Ne zaman bir eşleşmeme duruöu olursa, elimizde daha önce elde ettiğimiz bilgileri kullanarak, deseni kaydırma ve benzetme işlemi yaparız. Dolayısı ile gereksiz karşılaştırmadan kaçtığımız için zaman karmaşıklığından kazanmış oluruz.</p>
<p>LPS için aşağıdaki örnelere bakın.</p>
<div class="highlight"><pre><span></span><code> “AABAACAABAA”, lps = [0, 1, 0, 1, 2, 0, 1, 2, 3, 4, 5]
“ABCDE”, lps = [0, 0, 0, 0, 0]
“AAAAA”, lps = [0, 1, 2, 3, 4]
“AAABAAA”, lps = [0, 1, 2, 0, 1, 2, 3]
“AAACAAAAAC”, lps = [0, 1, 2, 0, 1, 2, 3, 3, 3, 4]
</code></pre></div>
<p>İşleyiş aşağıdaki kod ile daha iyi anlaşılacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">KMP_search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">lps</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">compute_lps_array</span><span class="p">(</span><span class="n">pattern</span><span class="p">)</span>
<span class="w"> </span><span class="n">m</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">),</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="nc">text</span><span class="p">),</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="nc">text</span><span class="w"> </span><span class="n">indeksi</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nl">n</span><span class="p">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pattern</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nc">text</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nl">m</span><span class="p">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">j</span><span class="p">)</span>
<span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">lps</span><span class="o">[</span><span class="n">j - 1</span><span class="o">]</span>
<span class="w"> </span><span class="n">elif</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">pattern</span><span class="o">[</span><span class="n">j</span><span class="o">]</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="nc">text</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="n">eşleşme</span><span class="w"> </span><span class="n">sonrası</span><span class="w"> </span><span class="n">eşleşmeme</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">lps</span><span class="o">[</span><span class="n">j - 1</span><span class="o">]</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">compute_lps_array</span><span class="p">(</span><span class="n">pattern</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">lps</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">)</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">len_sp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">son</span><span class="w"> </span><span class="n">en</span><span class="w"> </span><span class="n">uzun</span><span class="w"> </span><span class="k">prefix</span><span class="w"> </span><span class="n">suffix</span><span class="w"> </span><span class="n">uzunluğu</span>
<span class="w"> </span><span class="n">len_sp</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="n">len_pattern</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">pattern</span><span class="p">)</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nl">len_pattern</span><span class="p">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pattern</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">pattern</span><span class="o">[</span><span class="n">len_sp</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">len_sp</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">lps</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">len_sp</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">elif</span><span class="w"> </span><span class="n">len_sp</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="n">len_sp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">lps</span><span class="o">[</span><span class="n">len_sp - 1</span><span class="o">]</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span><span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">len_sp</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="n">lps</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">lps</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="nc">text</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"ABABDABACDABABCABAB"</span>
<span class="w"> </span><span class="n">pattern</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="ss">"ABABCABAB"</span>
<span class="w"> </span><span class="n">KMP_search</span><span class="p">(</span><span class="nc">text</span><span class="p">,</span><span class="w"> </span><span class="n">pattern</span><span class="p">)</span>
</code></pre></div>Sıralı dizi içerisinde hedef sayıya en yakın k sayı - Arama Algoritması2015-10-06T18:00:00+02:002015-10-06T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-06:/blog/search-k-closest/<p>Sıralı olarak verilen bir dizi içerisinde, hedef olarak belirtilen sayıya en yakın(eşit değil) k tane elemanı elde etmeye yarayan problemdir.</p>
<p>Problemin basit olarak çözümü, k tane elemanın bulunması için diziyi lineer olarak aramaktan geçer.</p>
<ol>
<li>İlk elemandan başlayarak geçit alanına kadar gel(Geçit alanı: Sonraki elemanın büyük, üzerinde bulunan elemanın …</li></ol><p>Sıralı olarak verilen bir dizi içerisinde, hedef olarak belirtilen sayıya en yakın(eşit değil) k tane elemanı elde etmeye yarayan problemdir.</p>
<p>Problemin basit olarak çözümü, k tane elemanın bulunması için diziyi lineer olarak aramaktan geçer.</p>
<ol>
<li>İlk elemandan başlayarak geçit alanına kadar gel(Geçit alanı: Sonraki elemanın büyük, üzerinde bulunan elemanın küçük veya eşit olduğu nokta). Karmaşıklık O(n)'dir.</li>
<li>
<ol>
<li>adımda bulunan noktanın her iki tarafını karşılaştırarak ekrana k tane eleman ver. Bu adım da O(k) zaman alır.</li>
</ol>
</li>
</ol>
<p>Genel olarak bu çözüm O(n) zaman alır.</p>
<p>Şimdi daha optimize ve O(logn + k) zaman alan bir çözümü inceleyelim. Bu çözüm aslında yukarıdaki çözüme benziyor fakat geçit bölgesini binary search algoritması ile buluyoruz(Dizi sıralı çünkü).</p>
<p>Çözüm aşağıdaki gibidir.</p>
<div class="highlight"><pre><span></span><code><span class="n">def</span><span class="w"> </span><span class="n">find_cross_point</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">low</span><span class="p">,</span><span class="w"> </span><span class="n">high</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="n">tüm</span><span class="w"> </span><span class="n">elemanlardan</span><span class="w"> </span><span class="n">büyükse</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">high</span><span class="o">]</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">high</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="n">tüm</span><span class="w"> </span><span class="n">elemanlardan</span><span class="w"> </span><span class="n">küçükse</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">low</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">low</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Orta</span><span class="w"> </span><span class="n">noktayı</span><span class="w"> </span><span class="n">bulma</span>
<span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">low</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">high</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">X</span><span class="w"> </span><span class="n">ortanca</span><span class="w"> </span><span class="n">elemansa</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid</span><span class="o">]</span><span class="w"> </span><span class="o"><=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid + 1</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">mid</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid</span><span class="o">]</span><span class="w"> </span><span class="n">ve</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid+1</span><span class="o">]</span><span class="w"> </span><span class="n">ise</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">mid</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">find_cross_point</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">high</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">find_cross_point</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">low</span><span class="p">,</span><span class="w"> </span><span class="n">mid</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span>
<span class="n">def</span><span class="w"> </span><span class="n">print_closest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">find_cross_point</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">)</span>
<span class="w"> </span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Eşit</span><span class="w"> </span><span class="n">elemanları</span><span class="w"> </span><span class="n">dikkate</span><span class="w"> </span><span class="n">alma</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">l</span><span class="o">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Geçiş</span><span class="w"> </span><span class="n">noktasından</span><span class="w"> </span><span class="n">itibare</span><span class="w"> </span><span class="n">sağ</span><span class="w"> </span><span class="n">ve</span><span class="w"> </span><span class="n">sol</span><span class="w"> </span><span class="n">kontrolu</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nl">k</span><span class="p">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">l</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">arr</span><span class="o">[</span><span class="n">r</span><span class="o">]</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="nl">x</span><span class="p">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">arr</span><span class="o">[</span><span class="n">l</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">else</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">arr</span><span class="o">[</span><span class="n">r</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Sağ</span><span class="w"> </span><span class="n">tarafta</span><span class="w"> </span><span class="n">hiç</span><span class="w"> </span><span class="n">eleman</span><span class="w"> </span><span class="n">yoksa</span><span class="w"> </span><span class="n">sol</span><span class="w"> </span><span class="n">tarafı</span><span class="w"> </span><span class="n">yazdır</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">arr</span><span class="o">[</span><span class="n">l</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="err">#</span><span class="w"> </span><span class="n">Sol</span><span class="w"> </span><span class="n">tarafta</span><span class="w"> </span><span class="n">hiç</span><span class="w"> </span><span class="n">eleman</span><span class="w"> </span><span class="n">yoksa</span><span class="w"> </span><span class="n">sağ</span><span class="w"> </span><span class="n">tarafı</span><span class="w"> </span><span class="n">yazdır</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">arr</span><span class="o">[</span><span class="n">r</span><span class="o">]</span><span class="p">)</span>
<span class="w"> </span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="nf">count</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">12, 16, 22, 30, 35, 39, 42,</span>
<span class="n"> 45, 48, 50, 53, 55, 56</span><span class="o">]</span>
<span class="w"> </span><span class="n">target</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">35</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span>
<span class="w"> </span><span class="n">print_closest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">target</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="p">)</span>
</code></pre></div>Hangi sıralama algoritması belleğe en az sayıda yazma yapar?2015-10-05T18:00:00+02:002015-10-05T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-05:/blog/which-sorting-min-memory/<p>Hafızaya yazma işlemini azaltmak, büyük veri kümeeleri üzerinde uğraşmanın maliyetli olduğu EEPROMs ve ya flash gibi platformlar için kazançlıdır.</p>
<p>Sıralama algoritmaları arasında <code>Selection Sort</code> agoritmasının en az sayıda yazma işlemi yaptığını(<code>O(n)</code>) biliyoruz. Fakat <code>Cycle Sort</code> neredeyse her zaman <code>Selection Sort</code> algoritmasına göre daha az sayıda yazma işlemi yapar …</p><p>Hafızaya yazma işlemini azaltmak, büyük veri kümeeleri üzerinde uğraşmanın maliyetli olduğu EEPROMs ve ya flash gibi platformlar için kazançlıdır.</p>
<p>Sıralama algoritmaları arasında <code>Selection Sort</code> agoritmasının en az sayıda yazma işlemi yaptığını(<code>O(n)</code>) biliyoruz. Fakat <code>Cycle Sort</code> neredeyse her zaman <code>Selection Sort</code> algoritmasına göre daha az sayıda yazma işlemi yapar. Eğer değer doğru noktada ise, o değer için hiç yazma işlemi yapılmaz ve eğer değer doğru noktada değilse bir kez yazma işlemi yapılarak doğru noktaya getirilir.</p>K. küçük veya büyük sayısı bulmak - Part 1 - Arama Algoritması2015-10-04T18:00:00+02:002015-10-04T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-04:/blog/search-k-largest-or-smalest/<p>Bir dizi ve <code>k</code> sayısı veriliyor(k < len(dizi)). Cevap olarak dizi içerisinde ki k. küçük veya büyük elemanın bulunması hedefleniyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">7</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">15</span><span class="o">}</span>
<span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">7</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">7</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">15</span><span class="o">}</span>
<span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">10</span>
</code></pre></div>
<h3>Çözüm 1 (Basit Çözüm …</h3><p>Bir dizi ve <code>k</code> sayısı veriliyor(k < len(dizi)). Cevap olarak dizi içerisinde ki k. küçük veya büyük elemanın bulunması hedefleniyor.</p>
<p>Örneğin;</p>
<div class="highlight"><pre><span></span><code><span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">7</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">15</span><span class="o">}</span>
<span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">7</span>
<span class="n">Input</span><span class="o">:</span><span class="w"> </span><span class="n">arr</span><span class="o">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="mi">7</span><span class="o">,</span><span class="w"> </span><span class="mi">10</span><span class="o">,</span><span class="w"> </span><span class="mi">4</span><span class="o">,</span><span class="w"> </span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">20</span><span class="o">,</span><span class="w"> </span><span class="mi">15</span><span class="o">}</span>
<span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span>
<span class="n">Output</span><span class="o">:</span><span class="w"> </span><span class="mi">10</span>
</code></pre></div>
<h3>Çözüm 1 (Basit Çözüm)</h3>
<p>Akla gelen en basit çözm elimizdeki veri kümesini ihtiyaca göre sıralamak ve k. indeksi çağırmak. Sıralama için kullanılacak en verimli algoritma ortalama <code>O(nlogn)</code> zaman alacağı için karmaşıklık <code>O(nlogn)</code> olacaktır.</p>
<h3>Çözüm 2 (Min Heap – HeapSelect)</h3>
<p>Bu problemi <code>O(nlogn)</code> zaman karma1şıklığından daha iyi bir şekilde çözebiliriz. Kullanacağımız algoritma, heap veri yapısı yardımı ile sonuca ulaşacaktır.</p>
<p>Çözüm aşağıdaki gibidir.</p>
<div class="highlight"><pre><span></span><code><span class="k">class</span><span class="w"> </span><span class="nl">MinHeap</span><span class="p">:</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">__init__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">arr</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">arr</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">min_heapify</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">min_heapify</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="n">smallest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="nf">left</span><span class="p">(</span><span class="n">i</span><span class="p">),</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="nf">right</span><span class="p">(</span><span class="n">i</span><span class="p">),</span><span class="w"> </span><span class="n">i</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">l</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">smallest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">l</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">r</span><span class="o">]</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">smallest</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">smallest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">r</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">smallest</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="nl">i</span><span class="p">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">smallest</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span>
<span class="n"> smallest</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">min_heapify</span><span class="p">(</span><span class="n">smallest</span><span class="p">)</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">extract_min</span><span class="p">(</span><span class="n">self</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="ow">not</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="nl">heap_size</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span>
<span class="w"> </span><span class="n">root</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">0</span><span class="o">]</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="mi">1</span><span class="err">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">self.heap_size - 1</span><span class="o">]</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">min_heapify</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">root</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="nf">left</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="nf">right</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">paremt</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="n">i</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="n">def</span><span class="w"> </span><span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MinHeap</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="n">k</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">heap</span><span class="p">.</span><span class="n">extract_min</span><span class="p">()</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">heap</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">0</span><span class="o">]</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">12, 3, 5, 7, 19</span><span class="o">]</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">))</span>
</code></pre></div>
<p>Bu algoritmanın karmaşıklığı <code>O(n+klogn)</code> olacakır.</p>
<h3>Çözüm 3 (Max-Heap)</h3>
<p>Çözüm 2'deki gibi, bu sefer max-heap ile problemi çözebiliriz.Karmaşıklık <code>O(k + (n-k)*logk)</code> olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="k">class</span><span class="w"> </span><span class="nl">MaxHeap</span><span class="p">:</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">__init__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">arr</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">arr</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="err">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">max_heapify</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">max_heapify</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="n">largest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="nf">left</span><span class="p">(</span><span class="n">i</span><span class="p">),</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="nf">right</span><span class="p">(</span><span class="n">i</span><span class="p">),</span><span class="w"> </span><span class="n">i</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">l</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">largest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">l</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">r</span><span class="o">]</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">largest</span><span class="o">]</span><span class="err">:</span>
<span class="w"> </span><span class="n">largest</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">r</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">largest</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="nl">i</span><span class="p">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">largest</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span>
<span class="n"> largest</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">i</span><span class="o">]</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">max_heapify</span><span class="p">(</span><span class="n">largest</span><span class="p">)</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">extract_max</span><span class="p">(</span><span class="n">self</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="ow">not</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="nl">heap_size</span><span class="p">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span>
<span class="w"> </span><span class="n">root</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">0</span><span class="o">]</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="mi">1</span><span class="err">:</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">self.heap_size - 1</span><span class="o">]</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">max_heapify</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="w"> </span><span class="n">self</span><span class="p">.</span><span class="n">heap_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">root</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="nf">left</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="nf">right</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">2</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">2</span>
<span class="w"> </span><span class="n">def</span><span class="w"> </span><span class="n">paremt</span><span class="p">(</span><span class="n">self</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="n">i</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="mi">2</span>
<span class="n">def</span><span class="w"> </span><span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MaxHeap</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="k">range</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">k</span><span class="p">)</span><span class="err">:</span>
<span class="w"> </span><span class="n">heap</span><span class="p">.</span><span class="n">extract_max</span><span class="p">()</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">heap</span><span class="p">.</span><span class="n">harr</span><span class="o">[</span><span class="n">0</span><span class="o">]</span>
<span class="k">if</span><span class="w"> </span><span class="n">__name__</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s1">'__main__'</span><span class="err">:</span>
<span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">[</span><span class="n">12, 3, 5, 7, 19</span><span class="o">]</span>
<span class="w"> </span><span class="k">print</span><span class="p">(</span><span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">))</span>
</code></pre></div>
<h3>Çözüm 4 (QuickSelect)</h3>
<p>Bu çözüm, çözüm 1 de bahsedilen yöntemin optimize edilmiş halini yansıtmaktadır.Quick sort algoritmasının modifiye edilmesi ile elde edilmiştir. Pivot eleman seçeceğiz, bunu doğru pozisyona yerleştireceğiz ve etrafını parçalayacaız. En kötü durumda karmaşıklık <code>O(n^2)</code>, fakat ortalama durumda <code>O(n)</code> olacaktır.</p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">inf</span>
<span class="k">def</span> <span class="nf">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">,</span> <span class="n">k</span><span class="p">):</span>
<span class="k">if</span> <span class="n">k</span> <span class="o">></span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">k</span> <span class="o"><=</span> <span class="n">r</span> <span class="o">-</span> <span class="n">l</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">pos</span> <span class="o">=</span> <span class="n">partition</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">)</span>
<span class="k">if</span> <span class="n">pos</span> <span class="o">-</span> <span class="n">l</span> <span class="o">==</span> <span class="n">k</span> <span class="o">-</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span> <span class="n">arr</span><span class="p">[</span><span class="n">pos</span><span class="p">]</span>
<span class="k">if</span> <span class="n">pos</span> <span class="o">-</span> <span class="n">l</span> <span class="o">></span> <span class="n">k</span> <span class="o">-</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span> <span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">pos</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">k</span><span class="p">)</span>
<span class="k">return</span> <span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">pos</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">r</span><span class="p">,</span> <span class="n">k</span> <span class="o">-</span> <span class="n">pos</span> <span class="o">+</span> <span class="n">l</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
<span class="k">return</span> <span class="n">inf</span>
<span class="k">def</span> <span class="nf">partition</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">i</span> <span class="o">=</span> <span class="n">arr</span><span class="p">[</span><span class="n">r</span><span class="p">],</span> <span class="n">l</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">):</span>
<span class="k">if</span> <span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o"><=</span> <span class="n">x</span><span class="p">:</span>
<span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">arr</span><span class="p">[</span><span class="n">r</span><span class="p">]</span> <span class="o">=</span> <span class="n">arr</span><span class="p">[</span><span class="n">r</span><span class="p">],</span> <span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">return</span> <span class="n">i</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">12</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">19</span><span class="p">,</span> <span class="mi">26</span><span class="p">]</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kth_smallest</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">))</span>
</code></pre></div>Sıralama algoritmalarında kararlılık nedir?2015-10-03T18:00:00+02:002015-10-03T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-03:/blog/stability-sorting/<p>Sıralama algoritmalarında bazen kararlılık ile ilgili bir takım bilgiler görürüz.Kısaca açıklamak gerekirse, sırarısz bir dizide aynı değerlere sahip elemanların dizilişi, dizi sıralandığında da korunuyorsa algoritma kararlıdır.</p>
<p>Kararlı özelliğine sahip algoritmalar; Insertion sort, Merge sort, Bubble sort. Kararsız olanlar; Heap sort, Quick sort.</p>
<p>Ancak verilen kararlı olmayan aloritmalar kolayca kararlı …</p><p>Sıralama algoritmalarında bazen kararlılık ile ilgili bir takım bilgiler görürüz.Kısaca açıklamak gerekirse, sırarısz bir dizide aynı değerlere sahip elemanların dizilişi, dizi sıralandığında da korunuyorsa algoritma kararlıdır.</p>
<p>Kararlı özelliğine sahip algoritmalar; Insertion sort, Merge sort, Bubble sort. Kararsız olanlar; Heap sort, Quick sort.</p>
<p>Ancak verilen kararlı olmayan aloritmalar kolayca kararlı hale getirelebilirler.</p>Quick sort için en kötü durum nedir?2015-10-03T18:00:00+02:002015-10-03T18:00:00+02:00Buraktag:www.koseburak.net,2015-10-03:/blog/worstcase-quicksort/<p>Quick sort ortalama zamanda çalıştığında en verimli çalışan ve en çok kullanılan algoritmalardan biridir. Pivot seçiminin ne kadar önemli olduğunu algoritmayı incelediğinizde göreceksiniz.</p>
<p>En kötü duruma sebebiyet veren şartlar aşağıdadır.</p>
<ol>
<li>Dizi zaten aynı yönde sıralıysa.</li>
<li>Dizi ters yönde sıralıysa.</li>
<li>Tüm elemanlar aynıysa</li>
</ol>Apache Spark - Part 1 : Tanıtım2015-06-21T22:00:00+02:002015-06-21T22:00:00+02:00Buraktag:www.koseburak.net,2015-06-21:/blog/apache-spark-part1/<p>Apache Spark,büyük veri işleme amacı ile oluşturulmuş bir Apache projesidir.Scala dili ile yazılmış JVM üzerinde çalışan ve Python, Java, Scala kullanımına olanak sağlayan, "in-memory" yani veriyi bellek içerisinde işleme özelliği ile ön plana çıkan bir projedir.</p>
<p>Eğer isterseniz kaynak kodları görüntülemek için aşağıdaki adrese göz atabilirsiniz.</p>
<p><a href="https://github.com/apache/spark">https://github …</a></p><p>Apache Spark,büyük veri işleme amacı ile oluşturulmuş bir Apache projesidir.Scala dili ile yazılmış JVM üzerinde çalışan ve Python, Java, Scala kullanımına olanak sağlayan, "in-memory" yani veriyi bellek içerisinde işleme özelliği ile ön plana çıkan bir projedir.</p>
<p>Eğer isterseniz kaynak kodları görüntülemek için aşağıdaki adrese göz atabilirsiniz.</p>
<p><a href="https://github.com/apache/spark">https://github.com/apache/spark</a></p>
<h1><em>Kurulum</em></h1>
<p><a href="http://spark.apache.org/downloads.html">http://spark.apache.org/downloads.html</a> adresinden “Pre-built for Hadoop 2.6 and later” seçeneği seçilerek son sürümünü indirebilirsiniz.İndirme tamamlandıktan sonra indirilen yere geçirelerek,</p>
<p><code>tar -xzvf spark-1.4.0-bin-hadoop2.6.tgz</code></p>
<p><code>cd spark-1.4.0-bin-hadoop2.6</code></p>
<p><code>ls</code></p>
<p>komutları yürütülür.Son komuttan sonra sergilenen dosyaları kısaca şu şekilde açıklayabiliriz.</p>
<ul>
<li>README.md</li>
</ul>
<p><code>Spark ile ilgili kısa açıklamalar ve hızlı başlangıç</code></p>
<ul>
<li>bin</li>
</ul>
<p><code>Çalıştırılabilir dosyalar(shell gibi)</code></p>
<ul>
<li>core,streaming,Python..</li>
</ul>
<p><code>Spark projesinin kaynak kodları</code></p>
<ul>
<li>examples</li>
</ul>
<p><code>Örnekler</code></p>
<h1><em>Tanıtım</em></h1>
<p>Yazının devamında Spark'ı yerel modda çalıştırarak kısa bir kaç örnek yapalım.Ben Python kullanıyor olacağım eğer siz tercih ederseniz Scala veya Java kullanabilirsiniz fakat Java hakkında bahsetmek istediğim bir nokta var eğer Java 8 ile birlikte gelen özellikleri kullanmazsanız nispeten biraz okuması zor bir kod çıkabilir ortaya fakat performanstan bir kaybınız olmaz.</p>
<ul>
<li>İnteraktif Python Shell</li>
</ul>
<p><code>./bin/pyspark</code></p>
<ul>
<li>İnteraktif Scala Shell</li>
</ul>
<p><code>./bin/spark-shell</code></p>
<p>Python shell için yukarıdaki komutu çalıştırdıktan sonra şu şekilde bir görüntü elde ediyorum.</p>
<p><center><img src="/images/apache_spark/1/1.png" height = 240px width = 400px></center></p>
<p>Eğer konsola düşen "INFO" loglarını gizlemek isterseniz.Şunu yapabilirsiniz.</p>
<blockquote>
<p>"conf/log4j.properties.template"</p>
</blockquote>
<p>dosyasının bir kopyasını alın ve</p>
<blockquote>
<p>"conf/log4j.properties"</p>
</blockquote>
<p>ismini verin.Daha sonra bu kopya dosya içerisindeki "log4j.rootCategory=INFO, console" satırını "log4j.rootCategory=WARN, console" ile değiştirin.Artık INFO loglarını görmeyeceksiniz.</p>
<p>Devam edelim,interaktif Python Shell açtıktan sonra</p>
<div class="highlight"><pre><span></span><code>>>> lines = sc.textFile("README.md")
>>> type(lines)
<class 'pyspark.rdd.RDD'>
>>> lines.count()
98
>>> lines.first()
'# Apache Spark'
</code></pre></div>
<p>gibi bir örnek ile test edelim.Yukarıdada göreceğiniz gibi <em>lines</em> adı ile kullandığımız değişkten bir RDD objesidir ve yerel makinemizde bulunan bir text dosyasından oluşturulmuştur.RDD hakkında ileriki yazılarımda daha fazla detay vereceğim.</p>
<p>Yukarıdaki örnekte birde <em>sc</em> objesi kullandık.Bu obje sayesinde Spark ile iletişim kurulur.</p>
<div class="highlight"><pre><span></span><code>>>> sc
<pyspark.context.SparkContext object at 0x7f9b3e856e48>
</code></pre></div>
<p>Spark aşağıdaki görseldeki gibi çalışır.
<center>
<img alt="workflow" src="/images/apache_spark/1/2.png"></center></p>
<p>Şimdi de bu uygulamamızda <em>filter</em> kullanarak içerisinde "Python" geçen satırları veren bir örnek yapalım.</p>
<div class="highlight"><pre><span></span><code>>>> lines = sc.textFile("README.md")
>>> pythonLines = lines.filter(lambda line : 'Python' in line)
>>> type(pythonLines)
<class 'pyspark.rdd.PipelinedRDD'>
>>> pythonLines.count()
3
>>> pythonLines.first()
'high-level APIs in Scala, Java, and Python, and an optimized engine that'
</code></pre></div>
<p>Gibi bir çıktı alırız.Eğer Python'da lambda fonksiyonlara alışık değilseniz ya da kullanmak istemezseniz yukarıda kullandığımız <em>filter()</em> methoduna kendi oluşturduğunuz methodu da aktarabilirsiniz.Örnek;</p>
<div class="highlight"><pre><span></span><code><span class="o">>>></span><span class="w"> </span><span class="nv">def</span><span class="w"> </span><span class="nv">hasPython</span><span class="ss">(</span><span class="nv">line</span><span class="ss">)</span>:
...<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="s1">'Python'</span><span class="w"> </span><span class="nv">in</span><span class="w"> </span><span class="nv">line</span>
...
<span class="o">>>></span><span class="w"> </span><span class="nv">pythonLines</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">lines</span>.<span class="nv">filter</span><span class="ss">(</span><span class="nv">hasPython</span><span class="ss">)</span>
</code></pre></div>
<p>gibi bir kullanım geçerleyebilirsiniz.</p>
<p>İnteraktif shell kullanışlı olsa da her zaman kullanamayız.Bazen bağımsız uygulamalar yazmamız gerekmektedir.Yazılan kodları yürütmek için indirdiğimiz Spark klasöründeyken <code>./bin/pyspark benim_script.py</code> komutunu yürütmek zorundayız.Bunun yerine aşağıdaki yolları izleyerek işimizi biraz daha kolaylaştıralım.</p>
<div class="highlight"><pre><span></span><code>cd ~
nano .bashrc
</code></pre></div>
<p>ve aşağıdaki satırları düzenleyip dosyamıza ekleyelim.</p>
<blockquote>
<p>export SPARK_HOME= 'Spark dosyası uzantısı'</p>
<p>export PYTHONPATH=$SPARK_HOME/python/:$PYTHONPATH</p>
</blockquote>
<div class="highlight"><pre><span></span><code>. .bashrc
</code></pre></div>
<p>PySpark'ın <code>py4j</code> adlı pakete bağımlılığı vardır.Bu paket Python yorumlayıcısının dinamik bir şekilde Spark ile haberleşmesini sağlar.</p>
<p><code>pip install py4j</code></p>
<p>Yazdığımız kodları artık
<code>./bin/spark-submit <python_file.py></code>
yerine direk olarak
<code>python <python_file.py></code> şeklinde çalıştırabileceğiz.</p>
<p>Bundan sonra kod yazarken yapmamız gereken tek şey <em>SparkContext</em> objemizi oluşturmaktır,geri kalan kısımlar aynıdır.</p>
<p>Yazımın başında Python kullandığımı söylemiştim fakat siz Scala veya Java kullanıyorsanuz bağımsız uygulamalar yazarken Maven kullanmanızı öneririm.Maven kullanımı ile ilgili resmi dökümanlara bakarak yardım alabilirsiniz.</p>
<p>Yazılan uygulamanın Spark ile iletişim kurabilmesi için Spark paketlerini dahil etmeli ve <em>SparkContext</em> nesnesini yaratmalıyız.</p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">pyspark</span> <span class="kn">import</span> <span class="n">SparkConf</span><span class="p">,</span> <span class="n">SparkContext</span>
<span class="n">conf</span> <span class="o">=</span> <span class="n">SparkConf</span><span class="p">()</span><span class="o">.</span><span class="n">setMaster</span><span class="p">(</span><span class="s2">"local"</span><span class="p">)</span><span class="o">.</span><span class="n">setAppName</span><span class="p">(</span><span class="s2">"My App"</span><span class="p">)</span>
<span class="n">sc</span> <span class="o">=</span> <span class="n">SparkContext</span><span class="p">(</span><span class="n">conf</span> <span class="o">=</span> <span class="n">conf</span><span class="p">)</span>
</code></pre></div>
<p>Yazdığımız script'i
<code>python benim_script.py</code></p>
<p>şeklinde çalıştırabilirsiniz.</p>
<p>Bu örnek ile basit olarak <em>SparkContext</em> oluşturmayı gördük.Aktarılan iki parametre sırası ile;</p>
<ol>
<li>Cluster URL , bu örnekte "local" olmasının sebebi Spark'ı tek bir makinede ve tek bir thread üzerinde çalıştırdığımız içindir.</li>
<li>Uygulama ismi</li>
</ol>
<p>Bu parametreler dışında parametreler bulunmaktadır,ileride daha ayrıntılı inceliyor olacağız.</p>
<p>Eğer uygulamayı sonlandırmak isterseniz SparkContext objesi üzerinden
<strong>stop()</strong> methodunu çağırabilir veya alışık olduğumuz <strong>sys.exit()</strong> kullanabilirsiniz.</p>
<p>Bu kadar kargaşadan sonra sıra "Hello World" uygulamamıza geldi.Bu alanın "Hello World" uygulaması "Word Count" olarak geçer.Basit bir word count uygulaması yazalım.</p>
<div class="highlight"><pre><span></span><code><span class="kn">from</span> <span class="nn">operator</span> <span class="kn">import</span> <span class="n">add</span>
<span class="kn">from</span> <span class="nn">pyspark</span> <span class="kn">import</span> <span class="n">SparkContext</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">sc</span> <span class="o">=</span> <span class="n">SparkContext</span><span class="p">(</span><span class="n">appName</span><span class="o">=</span><span class="s2">"WordCount"</span><span class="p">)</span>
<span class="n">lines</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="n">textFile</span><span class="p">(</span><span class="s1">'README.md'</span><span class="p">)</span>
<span class="n">counts</span> <span class="o">=</span> <span class="n">lines</span><span class="o">.</span><span class="n">flatMap</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">' '</span><span class="p">))</span> \
<span class="o">.</span><span class="n">map</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span> \
<span class="o">.</span><span class="n">reduceByKey</span><span class="p">(</span><span class="n">add</span><span class="p">)</span>
<span class="n">output</span> <span class="o">=</span> <span class="n">counts</span><span class="o">.</span><span class="n">collect</span><span class="p">()</span>
<span class="k">for</span> <span class="p">(</span><span class="n">word</span><span class="p">,</span> <span class="n">count</span><span class="p">)</span> <span class="ow">in</span> <span class="n">output</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">%s</span><span class="s2">: </span><span class="si">%i</span><span class="s2">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">word</span><span class="p">,</span> <span class="n">count</span><span class="p">))</span>
<span class="n">sc</span><span class="o">.</span><span class="n">stop</span><span class="p">()</span>
</code></pre></div>
<p>Kod içerisinde yabancı gelen terimleri bir sonraki yazılarda daha ayrıntılı bir biçimde inceliyor olacağız.</p>
<p>BURAK KÖSE</p>Rastgele Sayı Üretmek2014-12-05T05:57:00+01:002014-12-05T05:57:00+01:00Buraktag:www.koseburak.net,2014-12-05:/blog/rastgele-sayi/<p>Rastgele yani tesadüfen , tesadüfi olarak , ayırmadan , seçmeden
anlamındadır.Çoğumuz yazdığımız kodu test ederken , oyun programlarken
ve çişitli hesaplamarda kullanırız rastgele sayıları.Günlük hayatta
rastgele kavramı insalar için keyfi olarak kullanılır.Aklınızdan bir
sayı tutup söylersiniz bu bir rastgele işlemidir.Peki gerçekten
böylemidir,bilgisayarlar için de durum bu mudur?</p>
<p>Hep verilen …</p><p>Rastgele yani tesadüfen , tesadüfi olarak , ayırmadan , seçmeden
anlamındadır.Çoğumuz yazdığımız kodu test ederken , oyun programlarken
ve çişitli hesaplamarda kullanırız rastgele sayıları.Günlük hayatta
rastgele kavramı insalar için keyfi olarak kullanılır.Aklınızdan bir
sayı tutup söylersiniz bu bir rastgele işlemidir.Peki gerçekten
böylemidir,bilgisayarlar için de durum bu mudur?</p>
<p>Hep verilen bir örnek vardır , zar.Zar atma olayı rastgele midir ? Bize
göre evet fakat matematikte durum böyle değildir.Zarın hangi sayı
gelmesi bir çok etkene bağlıdır.Bunlar sürtünme,ağırlık,yerçekimi,hız vs
gibi.Dolayısı ile gelecek sayının ne olduğu kestirilemediği için
rastgele denilir.</p>
<p>Biraz daha zorlayalım , mesela aklınzdan bir sayı tutup söyleme
gerçekten de rastgele midir ? Değildir. Çok hızlı karar verdiğimiz için
nasıl seçtiğimizi pek anlayamayız.Aslında bizim söyleyeceğimiz sayınında
etkenleri vardır.Örneğin favori sayımız , söylenecek sayının
sınırlandırılması gibi.</p>
<p>Uygulamamızda rastgele sayı elde etmek için çeşitli kütüphaneler ,
metodlar bulunur.Peki bunlar nasıl rastgele sayı üretiyorlar.Şimdi bir
kaç rastgele sayı üretme algoritmasına bakalım.</p>
<p><span style="color: #ff6600;"><strong>1# Orta kare yöntemi ( 4r )</strong></span></p>
<p>Bu algoritma <a href="https://tr.wikipedia.org/wiki/John_von_Neumann">John von
Neumann</a> ve ekip
arkadaşları tarafından ortaya atılmıştır.Kabaca şu şekilde gerçekleşir.</p>
<blockquote>
<p>1- 4r basamaklı bir sayı seçilir.'r' bir tamsayıdır.<br>
2- Sayının sağdan ve soldan 'r' adet basamağı silinir.<br>
3- Geriye kalan '2r' basamaklı sayının karesi bulunur fakat 'r'
sayısının tamsayı olması gerektiğini unutmayın.Kare alma işleminden
sonra elimizde tekrar 4r basamaklı bir sayı bulunur.<br>
4- Tekrar yeni bir sayı üretilmek istenirse 2. adıma geri dönülür.</p>
</blockquote>
<p>Bir örnek verelim.Sayımız 81.599.441 olsun.Tamamen salladığım bir sayı.8
basamaklıdır dolayısı ile r = 2 olur.Soldan ve sağdan r = 2 adet sayı
silelim.Yeni sayı 5994 olacaktır.Peki devam edelim 5994\^2 = 35.928.036
olur ve takrar r adet sayı soldan ve sağdan silelim.Yeni sayı 9280
olur.Devam etmek istersek bu böyle devam edecektir.Sayılar soldan
parçalanarak 2 basamaklı rastgele sayılar elde edilir.Örneğin 2
basamaklı rastgele sayılar için kümemiz {81,35} olurken üç basamaklı
sayılar için {815,359} olur.</p>
<p>Görüldüğü gibi çok pratik olmayan bir yöntemdim ve bazı soruları
vardır.Örneğin başlangıçta alınan 2500 sayısı için 50\^2 = 2500 elde
edilir ve bir çıkmaza girilir<strong>.</strong></p>
<p><strong><span style="color: #ff6600;"> </strong>2<strong>#</span></strong> <span
style="color: #ff6600;"><strong>Lineer Benzerlik Algoritması</strong></span></p>
<p>Daha önce C kullanmış olanlar bu algoritma onlara tanıdık gelecektir ve
ilk kez rastgele sayı oluşturan kişilerin genelde bunlar aynı sayılar
şeklinde devam ediyor , bu problem nedir dedikleri olmuştur(En azından
ben bu soruyu sormuştum).</p>
<p><a href="https://en.wikipedia.org/wiki/Derrick_Henry_Lehmer">D.H Lehmer</a>
tarafından geliştirilmiş rastgele sayı üretme algoritmasıdır.İlk olarak
s,c,b değişkenleri belirlenir.</p>
<blockquote>
<p>'s' başlangıç noktası<br>
'c' çarpım için<br>
'b' artış için<br>
'm' ise mod işlemi için belirlenen bir değerdir</p>
</blockquote>
<p>Algoritma şu şekilde işler.İlk olarak başlangıç noktası(s) çarpım için
belirlenmiş olan(c) ile çarpılır ve 'b' ile toplanır ve sonuç mod
işlemine alınır(m),ilk rastgele sayı üretilir.Bu işlem üretilen rastgele
sayının tekrar 'c' ile çarpılıp 'b' ile toplanıp 'm' ile modunu alınması
şeklinde devam eder.Örnek;</p>
<blockquote>
<p>s = 10<br>
c = 2<br>
b = 1<br>
m = 5 (Dikkat maksimum sayı 4 olabilir anlamına gelir)</p>
<p>1.Adım:<br>
(s*c + b ) % m yani (10 * 2 + 1) % 5 = 1 olacaktır ve yeni s = 1<br>
2.Adım:<br>
(1 * 2 + 1) % 5 = 3 olacaktır ve yeni s = 3<br>
3.Adım:<br>
(3 * 2 + 1) % 5 = 2 olacaktır ve yeni s = 2</p>
</blockquote>
<p>gibi işlemler devam edecektir.3 adımda 3 adet sayı ürettik bunlar
{1,3,2}'dir.Gerçek sayı üretme işlemlerinde bu değerler bu kadar küçük
seçilmezler.<a href="https://tr.wikipedia.org/wiki/Donald_Knuth">D.E Knuth</a> ve
<a href="https://en.wikipedia.org/wiki/Harold_Lewis">H.W. Lewis</a>tarafından
önerilen değerler ise;</p>
<blockquote>
<p>c = 1664525<br>
b = 1013904226<br>
m = 2 \^ 32</p>
</blockquote>
<p>Detaylı bilgi için
<a href="http://portals.omg.org/hpec/files/specs/vsipl/random.xhtml">bakın.</a></p>
<p>Şimdi gelelim şu C'de yaşanılan probleme.Bilindiği gibi
<a href="http://www.cplusplus.com/reference/cstdlib/rand/">rand()</a> fonksiyonu
geriye bir rastgele sayı döndürür fakat geri döndürdüğü sayılar belli
bir süre sonra tekrar ettiği görülür , hatırlarsınız orta karaler
yönteminde de benzer bir çıkmaza giriliyordu.Yani başlangıç için
belirlenen değer zamanla değiştirilmez.Bunun için
<a href="http://www.cplusplus.com/reference/cstdlib/srand/">srand()</a> fonksiyonu
kullanılır.Bu ise başlangıç değerini değiştirir.</p>
<p><span style="color: #ff6600;"><strong>3# 147 Algoritması<br>
</strong></span><br>
İsimden anlaşılacağı gibi 147 sayısı kullanılarak sayı üretilir.</p>
<blockquote>
<p>1.Adım : 0 \< n \< 1 aralığında bir '0,abcdefg' sayısı seçilir.Burada
g = {1,3,7,9} olmak zorundadır.<br>
2.Adım : s = n * 147 elde edilir.<br>
3.Adım : s sayısından tam sayı kısmı çıkartılır.<br>
4.Adım : 2. adıma geri dönülür.</p>
</blockquote>
<p>Bir örnek verelim.Örneğin n = 0,1234567 olsun. s = 0,1234567 * 147 =
18,1481349 olarak bulunur ve 3. adıma göre s = 18,1481349 - 18 =
0,1481349 olarak güncellendikten sonra işlemler tekrar edilir.</p>
<p><span style="color: #ff6600;"><strong>4# Engel Algoritması<br>
</strong></span><br>
Bazen yeni bir formul ile karşılaştığımda genelde ilk tepkim bu
insanlar bu hesaplamarı bulurken bu absurd sabitler nereden geliyor diye
kendime soruyorum.Mesela 147 algoritmasında görüldüğü gibi neden 147 ?
Bu algoritmada da bir basit kullanılıyor.Bu seferki sabitimiz 'π'(pi)
ama işin ilginç yanı bu sabiti kullanmak zorunda değiliz.Sadece 1'e
yakın bir sayı olmasın yeter.</p>
<p>Rastgele sayı üretiminde tahmin edilebilirliğin çok düşük olması
gerektiğinden bahsetmiştik.Bu algoritmada sayılarda ki değişiklikler
belirsizdir.</p>
<p>Algoritma için tanımlama</p>
<blockquote>
<p>1.Adım : 0 \<= n \<= 1 koşulunu sağlayan bir sayı seçilir.<br>
2.Adım : u = (n + π ) \^ 8 elde edilir ve u'nun tam sayı kısmı atılır
ve n = geriye kalan sayı olur.<br>
3.Adım : 2.Adıma geri dönülür.</p>
</blockquote>
<p>Bir örnek verelim.</p>
<blockquote>
<p>n = 0 alalım.<br>
1.Sayı için : u = (0 + π)\^8 = 9450,116981 elde edilir ve n =
9450,116981 - 9450 = 0,116981 olur.<br>
2.Sayı için : u = (0,116981 + π)\^8 = 12662,5682884 elde edilir ve n
= 0,5682884 olur.</p>
</blockquote>
<p>BURAK KÖSE</p>Suffix Tree - String Algoritmaları2014-12-04T00:08:00+01:002014-12-04T00:08:00+01:00Buraktag:www.koseburak.net,2014-12-04:/blog/suffix-tree/<p>Biyoinformatik'de adı sıkça geçen algoritmalardan olan suffix tree veri
yapısı bir dizgi model(pattern) eşleştirme algoritmasıdır.Örneğin
elinizde uzun bir dizgi olsun ve siz bu dizgi içinde alt dizgiler aramak
ve hatta bu dizgilerden kaç adet bulunduğunu öğrenmek istiyorsunuz.İşte
bu veri yapısı bu işlemleri kolaylaştırmak ile birlikte gayet hızlı …</p><p>Biyoinformatik'de adı sıkça geçen algoritmalardan olan suffix tree veri
yapısı bir dizgi model(pattern) eşleştirme algoritmasıdır.Örneğin
elinizde uzun bir dizgi olsun ve siz bu dizgi içinde alt dizgiler aramak
ve hatta bu dizgilerden kaç adet bulunduğunu öğrenmek istiyorsunuz.İşte
bu veri yapısı bu işlemleri kolaylaştırmak ile birlikte gayet hızlı
işlem yapmamıza olanak sağlıyor.</p>
<p>Bu tip bir yöntem kullanmadan ilkel olarak çözüm olarak şunu
yapabilirdik.Ana dizgi içerisinde lineer olarak sırayla karşılaştırma
yapa yapa devam ederek sonuca ulaşabilirdik.Bu bir yöntemdir fakat dizgi
boyutları arttıkça bu işlem çok maliyetli olmaktadır.</p>
<p>Suffix tree incelemesi yapmadan önce suffix nedir bundan
bahsedelim.Suffix Türkçe'de son ek olarak geçer ve bir dizginin son
ekleri şu şekilde bulunur.Örnek:</p>
<blockquote>
<p>String = burak</p>
</blockquote>
<p>sonekler</p>
<blockquote>
<p>burak,urak,rak,ak,k</p>
</blockquote>
<p>olacaktır.Görüldüğü gibi n uzunluğunda bir dizgi n adet suffix
sahibidir.</p>
<p>Suffix tree oluşturmak için önce ihtiyacımız olan suffixleri bulmamız
gerekmektedir.Yukarıdaki örnekteki gibi suffixler elde edildikten sonra
bunlar uzunluklarına göre sıralanmalıdır.Örneğin</p>
<blockquote>
<p>String = xabxac</p>
</blockquote>
<p>için sonekler</p>
<blockquote>
<p>xabxac,abxac,bxac,xac,ac,c</p>
</blockquote>
<p>olarak elde edilikten sonra sırası ile 1,2,3,4,5,6 numaraları
verilir.Ağaç şu şekilde oluşturulur.Bir başlangıç noktası vardır ve
buradan dallanmalar yapılmaktadır.Önce 1 numara dallanır daha sonra
gelen 2 numaraya ait dizgi ile ortak başlangıç noktaları varsa bu
noktadan itibaren dallanma yapılır eğer yoksa yeni bir dallanma
yapılır.Şimdi adım adım ağacımızı oluşturalım.</p>
<p><strong><span style="color: #ff9900;">#1.Adım</span></strong><br>
İlk dallanmamızı 1 numaralı suffix ile yapıyoruz. </p>
<p><img alt="1" src="/images/suffix_tree/1.png"><br>
<span style="color: #ff9900;"><strong>#2.Adım</strong></span><br>
2 numaralı suffix olan "abxac"' için inceleme yapıldığında şuana kadar
başlangıç noktasından itibaren "a" ile başlayan bir dallanma
olmadığından yeni bir dallanma yapılır. </p>
<p><img alt="2" src="/images/suffix_tree/2.png"><br>
<span style="color: #ff9900;"> <strong>#3.Adım</strong></span><br>
3 numaralı suffix "bxac"' için inceleme yapıldığında "b" ile başlayan
bir dallanma olmadığından tekrar başlangıç noktamızdan yeni bir dallanma
yapılır. </p>
<p><img alt="3" src="/images/suffix_tree/3.png"><br>
<span style="color: #ff9900;"> <strong>#4.Adım</strong></span><br>
4 numaralı suffix "xac"' için inceleme yapıldığında bu noktada işin
şekli değişmektedir.Ağaca baktığımızda başlangıç noktasından itibaren
bir "x" ile başlangıç vardır.Hatta bir adım daha arama yaptığımızda
sadece "x" ile değil devam edildiğinde "xa" ile bir başlangıç olan
dallanma vardır(1 numaralı suffix).Dolayısı ile kesişme noktasından bir
dallanma yapılır. </p>
<p><img alt="4" src="/images/suffix_tree/4.png"><br>
<span style="color: #ff9900;"> <strong>#5.Adım</strong></span><br>
5 numaralı suffix "ac" için inceleme yapabilmek için tekrar root
noktasından taramaya başlıyoruz ve ilk olarak "a" başlangıcı
arıyoruz.Görüldüğü gibi en iyi kesişim 2 numaralı suffixtedir.Dolayısı
ile bir kesişim noktası yapıp yeni bir dallanma yaratıyoruz. </p>
<p><img alt="5" src="/images/suffix_tree/5.png"><br>
<span style="color: #ff9900;"> <strong>#6.Adım</strong></span><br>
Ve son olarak sırada 6 numaralı suffix olan "c" için incelemede.Tek
başına bir dallanma yapması gerektiği görülüyor. </p>
<p><img alt="6" src="/images/suffix_tree/6.png"></p>
<p>Ağaç oluşturulmuştur.Şimdi bir arama yapalım,örneğin "xa" , bu dizgi
içinde geçiyor mu ve geçiyorsa kaç kere geçiyor sorusuna cevap arayalım.</p>
<p>Ağaca bakmaya root noktasından başlayalım ve "xa" arayalım.Hemen root
noktasının altında "xa" başlangıcı ile karşılaşıldı.Dolayısı ile "xa"
eşlemesi sağlandı ama kaç tane "xa" olduğunu nereden anlayacağız?Kaç
tane "xa" olduğunu bulunan noktanın altında kaç tane dallanma varsa o
kadar "xa" vardır diyeceğiz.Baktığımızda iki adet dallanma olduğu
görülmektedir. </p>
<p><img alt="new6" src="/images/suffix_tree/new6.png"></p>
<p><strong>Peki "bxa" var mıdır ?</strong><br>
Ağaçta aramaya tekrar root noktasından başlanır ve sırayla "bxa"
aranır. </p>
<p><img alt="new6.1png" src="/images/suffix_tree/new6.1png.png"><br>
evet "bxa" vardır ve 1 kere bulunur.</p>
<p><strong>Peki "xb" var mı?</strong><br>
Hayır "xb" yoktur.Sebebi ise root noktasından aramaya başlandığında
"xb" eşlemesi ile başlayan bir dallanma bulunamamıştır.</p>
<p><span style="color: #ff9900;"><strong>Her dizgi bir suffix tree sahibi
midir?</strong></span></p>
<p>Her dizgi bir suffix tree sahibi değildir.Eğer bir dizginin suffixleri
prefixlerine eşitse bir suffix ağacı yoktur.Mesela "cdbcd" için inceleme
yapalım.</p>
<blockquote>
<p>Suffixlerin : cdbcd,dbcd,bcd,<strong>cd</strong>,d olduğunu biliyoruz.</p>
</blockquote>
<p>ve</p>
<blockquote>
<p>Prefixleri : c,<strong>cd</strong>,cdb,cdbc,cdbcd şeklindedir.</p>
</blockquote>
<p>Dizginin kendisi dikkate alınmadan incelendiğinde "cd" değerlerinin
ortak olduğu görülmektedir.Dolayısı ile "cdbcd" için bir suffix tree
çizilemez.Peki bu sorunu nasıl çözebiliriz ? Çok basit sadece "cdbcd"
stringinin sonuda bir "\$" ekleyerek.Eğer "cdbcd\$" için inceleme
yaparsanız bir sorun olmadığını göreceksiniz.</p>
<p>BURAK KÖSE</p>Radix Sort - Sıralama Algoritmaları2014-12-03T01:53:00+01:002014-12-03T01:53:00+01:00Buraktag:www.koseburak.net,2014-12-03:/blog/radix-sort/<p>Türkçe'de taban sıralaması , basamaklı sıralama , kök sıralaması veya
hane sıralaması olarak geçen bu algoritmada sıralanacak olan veriler
hanelerine göre sıralanır.En değersiz olan haneden en değerli haneye
doğru sıralama işlemi yapılır.</p>
<p>Sıralanacak verilerin tamsayı olduğu durumlarda kullanılan bu algoritma
işlenirken ilk olarak sıralanacak olan veri kümesindeki elemanların en
büyük elemanının …</p><p>Türkçe'de taban sıralaması , basamaklı sıralama , kök sıralaması veya
hane sıralaması olarak geçen bu algoritmada sıralanacak olan veriler
hanelerine göre sıralanır.En değersiz olan haneden en değerli haneye
doğru sıralama işlemi yapılır.</p>
<p>Sıralanacak verilerin tamsayı olduğu durumlarda kullanılan bu algoritma
işlenirken ilk olarak sıralanacak olan veri kümesindeki elemanların en
büyük elemanının kaç basamaklı olduğu tespit edildikten sonra sayıların
en değersiz olan basamağından itibaren incelenmeye başlanır ve yeni bir
diziye yerleştirilir.Bu işlem dizinin en büyük elemanının basamak sayısı
kadar tekrar edilir.</p>
<p>Bu algoritmanın çalışma zamanı O(nk) ve yer karmaşıklığı O(n+k)
olacaktır.Gayet iyi bir çalışma zamanına sahip olmasının nedeni bu
algoritmanın karşılaştırmalı bir sıralama algoritması olmamasıdır.En
büyük dezavantajı ise her basamak işlemi için yeni bir bellek alanı
gerektirmesidir.</p>
<p><span style="color: #ff9900;"><strong>Direkt Basamaklı SIralama ( Straight
Radix Sort)</strong></span> algoritmasına bir örnek verelim.</p>
<p>Sayılarımız : 32 , 224 , 16 , 15 , 31 , 169 , 123 , 252 olsun ve
çözümümüz için aşağıdaki gibi bir tablo ile daha rahat işlemlerimiz
anlaşılır.</p>
<p>İlk olarak sayılar aşağıdaki gibi tabloya yerleştirildi.<br>
<div class="justtable">
<table>
<thead>
<tr>
<th><br></th>
</tr>
</thead>
<tbody>
<tr>
<td>Hane3,Hane2,Hane1<br></td>
</tr>
<tr>
<td>0,3,2<br></td>
</tr>
<tr>
<td>2,2,4<br></td>
</tr>
<tr>
<td>0,1,6<br></td>
</tr>
<tr>
<td>0,1,5<br></td>
</tr>
<tr>
<td>0,3,1<br></td>
</tr>
<tr>
<td>1,6,9<br></td>
</tr>
<tr>
<td>1,2,3<br></td>
</tr>
<tr>
<td>2,5,2</td>
</tr>
</tbody>
</table>
</div><br>
Hane1'e göre sıralama gerçekleştirildi.<br>
<div class="justtable">
<table>
<thead>
<tr>
<th><br></th>
</tr>
</thead>
<tbody>
<tr>
<td>Hane3,Hane2,Hane1<br></td>
</tr>
<tr>
<td>0,3,1<br></td>
</tr>
<tr>
<td>0,3,2<br></td>
</tr>
<tr>
<td>2,5,2<br></td>
</tr>
<tr>
<td>1,2,3<br></td>
</tr>
<tr>
<td>2,2,4<br></td>
</tr>
<tr>
<td>0,1,5<br></td>
</tr>
<tr>
<td>0,1,6<br></td>
</tr>
<tr>
<td>1,6,9<br></td>
</tr>
</tbody>
</table>
</div><br>
Hane1 sıralaması bittikten sonra Hane2 sıralaması gerçekleştirildi.<br>
<div class="justtable">
<table>
<thead>
<tr>
<th><br></th>
</tr>
</thead>
<tbody>
<tr>
<td>Hane3,Hane2,Hane1<br></td>
</tr>
<tr>
<td>0,1,5<br></td>
</tr>
<tr>
<td>0,1,6<br></td>
</tr>
<tr>
<td>1,2,3<br></td>
</tr>
<tr>
<td>2,2,4<br></td>
</tr>
<tr>
<td>0,3,1<br></td>
</tr>
<tr>
<td>0,3,2<br></td>
</tr>
<tr>
<td>2,5,2<br></td>
</tr>
<tr>
<td>1,6,9<br></td>
</tr>
</tbody>
</table>
</div><br>
ve son olarak maksimum sayımızın hane sayısına ulaşıldı ve Hane3'e göre
sıralama gerçekleştirildi.<br>
<div class="justtable">
<table>
<thead>
<tr>
<th><br></th>
</tr>
</thead>
<tbody>
<tr>
<td>Hane3,Hane2,Hane1<br></td>
</tr>
<tr>
<td>0,1,5<br></td>
</tr>
<tr>
<td>0,1,6<br></td>
</tr>
<tr>
<td>0,3,1<br></td>
</tr>
<tr>
<td>0,3,2<br></td>
</tr>
<tr>
<td>1,2,3<br></td>
</tr>
<tr>
<td>1,6,9<br></td>
</tr>
<tr>
<td>2,2,4<br></td>
</tr>
<tr>
<td>2,5,2<br></td>
</tr>
</tbody>
</table>
</div></p>
<p>Her şey güzel peki sayının kaç basamaklı olduğunu nereden anlayacağız
diyorsanız.</p>
<blockquote>
<p>basamak sayısı = int(log(taban,max) + 1)</p>
</blockquote>
<p>Örneğin üstteki örneğimizde en büyük eleman 252 sayısı ve bu sayılar 10
tabanındadır.Dolayısı ile<br>
log(10,252) + 1 = 3,401 olur ve bunu int çevirirsek = 3 çıkar.Şimdi bu
algoritmamızın örnek kodlarına gelelim. </p>
<div class="gist">
<script src='https://gist.github.com/7160796469da0dc175b0.js'></script>
<noscript>
<pre><code>from math import log
def getEmptyList(size):
# Boş bir liste döndürür
return [ [] for i in range(size) ]
def getDigit(num, base, digit_num):
# Hanelere göre değeri seçer
# Örnek 123 sayısının ilk hanesi = 3
return (num // base ** digit_num) % base
def maxWithAbs(p_list):
# Maksimum sayıyı işaret farkı olmadan döndürür
return max(abs(dig) for dig in p_list)
def mergeList(p_list):
# Parametre olarak aldığı listeyi birlştirir
new_list = []
for sub in p_list:
new_list.extend(sub)
return new_list
def split(s_list , base , digitNum):
temp_list = getEmptyList(base)
for number in s_list:
temp_list[getDigit(number, base, digitNum)].append(number)
return temp_list
def splitBySign(p_list):
# işaretli sayıları gruplar
buffer = [[], []]
for num in p_list:
if num < 0:
buffer[0].append(num)
else:
buffer[1].append(num)
return buffer
def radixSort(_list,base):
digitNum = int(log(maxWithAbs(_list),base) + 1)
for dig in range(digitNum):#İşaretlere bakmaksızın sıralıyor
_list = mergeList(split(_list, base, dig))
return mergeList(splitBySign(_list))#işaretleri dikkate alıyor ve düzenliyor
liste = [123,113,55,11,56,7,1,-1,2]
print(radixSort(liste, 10))</code></pre>
</noscript>
</div>
<p><span style="color: #ff9900;"><strong>Basamaklı Yer Değiştirme
Sıralaması(Radix Exchange Sort)</strong></span></p>
<p>Şimdi direkt yerleştirmeli sıralamanın düzenlemiş hali olan Basamaklı
Yer Değiştirme Sıralaması'nı inceleyelim.Kısaca farkları şudur.Direkt
basamaklı sıralama algoritmasında sağdan-sola doğru yol alınırken bu
yaklaşımda soldan-sağa doğru yol alınır ve en önemli avantajı bu
algoritmada her basamak için özel bir bellek alanına ihtiyaç
duyulmayacaktır.Bu algoritma içerisinde<a href="http://blog.koseburak.net/quick-sort/">Quick Sort(Hızlı
Sıralama)</a> algoritması
kullanılmıştır.</p>
<p>Sayılar ikili(binary) olarak tutulduğundan taban değişimi için ek bir
işlem yapılmasına gerek yoktur.Algoritmanın kodunu verirken biraz
modifiye ettiğimden söz etmeliyim.Ufak değişiklikler ile negatif sayılar
içinde işleyebilmesi için düzenledim.</p>
<div class="gist">
<script src='https://gist.github.com/4f95b6ad2890d02759e7.js'></script>
<noscript>
<pre><code>from math import log
def swap(n1,n2):
return n2 , n1
def getDigit(num, digit_num):
return (num >> digit_num) & 0x01
def splitBySign(p_list):
# işaretli sayıları gruplar
buffer = [[], []]
for num in p_list:
if num < 0:
buffer[0].append(num)
else:
buffer[1].append(num)
return buffer
def exchange(liste,down,up,digit):
if up > down and digit >= 0:
_down , _up = down , up
while(_up > _down):
while(getDigit(liste[_down], digit) == 0 and _down < _up):
_down += 1
while(getDigit(liste[_up], digit) == 1 and _down < _up):
_up -= 1
liste[_down] , liste[_up] = swap(liste[_down], liste[_up])
if(getDigit(liste[up], digit) == 0):
_up += 1
exchange(liste,down,_up -1,digit -1)
exchange(liste,_down,up,digit-1)
def RadixExchangeSort(p_list):
temp_buffer = splitBySign(p_list) #sayıları işaretine göre gruplandırdık
negative_list , possitive_list = temp_buffer[0] , temp_buffer[1]
if len(negative_list) > 0:#Eğer negatif sayı varsa
exchange(negative_list,0,len(negative_list)-1,int(log(abs(min(negative_list)),2) + 1))
if len(possitive_list) > 0:#Eğer pozitif sayı varsa
exchange(possitive_list,0,len(possitive_list)-1,int(log(max(possitive_list),2) + 1))
return negative_list + possitive_list
#Deneme
liste = [31,30,29,-10,3,1,6,8,-123,-1233,-999]
print(RadixExchangeSort(liste))
</code></pre>
</noscript>
</div>
<p>BURAK KÖSE</p>Quick Sort - Sıralama Algoritmaları2014-11-27T12:00:00+01:002014-11-27T12:00:00+01:00Buraktag:www.koseburak.net,2014-11-27:/blog/quick-sort/<p>Quick sort, Türkçe hızlı arama olan bu algoritma günümüzde en çok
tercih edilen sıralama algoritmasıdır.1960 yılında C. A. R. Hoare
tarafından ortaya atılmıştır.Bu algoritma yaklaşım bakımından "parçala
ve çözümle" ilkesine göre çalışmaktadır.</p>
<p>Bu yaklaşım şu şekilde açıklanabilir.Eldeki problem çok daha ufak
problemciklere ayrılır ve bütün bu problemcikler …</p><p>Quick sort, Türkçe hızlı arama olan bu algoritma günümüzde en çok
tercih edilen sıralama algoritmasıdır.1960 yılında C. A. R. Hoare
tarafından ortaya atılmıştır.Bu algoritma yaklaşım bakımından "parçala
ve çözümle" ilkesine göre çalışmaktadır.</p>
<p>Bu yaklaşım şu şekilde açıklanabilir.Eldeki problem çok daha ufak
problemciklere ayrılır ve bütün bu problemcikler tek tek çözülerek
birleştirilir ve sonuç elde edilir.Örneğin çarpılacak iki matrisin daha
küçük matrislere ayrılarak işlem yapılıp sonucun birleştirilerek elde
edilmesi.</p>
<p>Şimdi gelelim algoritmanın çalışma şekline.İlk olarak sıralanacak veri
kümesini parçalayacak bir pivot seçilir.Geriye kalan elemanlar pivotun
sağına ve soluna yerleştirilir.Bu yerleştirme seçilen pivotun solunda
kalan elemanlar pivottan küçükler , sağında kalanlar ise pivottan büyük
elemanlar olacaktır , eşit olanların ise ne tarafa yerleştiklerinin bir
önemi yoktur.Bu işlem ardından yukarıdaki işlemler tüm parçalanmış
diziler içinde tekrarlanır ve sonuç olarak sıralanmış dizi elde edilir.</p>
<p>Bu algoritmanın ortalama çalışma zamanının karmaşıklığı O(nlogn)
'dir.Sebebi veri kümesi her seferinde ikiye bölünerek devam eder(logn)
ve n adet eleman için sıralama yapılır.Algoritma en kötü durumda O(n\^2)
ile çalışır.En kötü durum oluşması için seçilen pivot , veri kümesinin
en küçük ya da en büyük büyük elemanı olması ile oluşur.</p>
<p>Aşağıdaki animasyon</p>
<p><center>
<img alt="Quick Sort" src="https://upload.wikimedia.org/wikipedia/commons/9/9c/Quicksort-example.gif"><br>
<em>(Alıntı : wikipedia)</em>
ve video sonrası anlamak daha kolay olacaktır.
<iframe src="//www.youtube.com/embed/ywWBy6J5gz8" width="560" height="315" frameborder="0" allowfullscreen="allowfullscreen"></iframe>
</center></p>
<div class="gist">
<script src='https://gist.github.com/b53e632cedeb46078f7d.js'></script>
<noscript>
<pre><code>public static void quickSort(int[] arr, int left, int right) {
int pivot = arr[(left + right) / 2];
int _left = left;
int _right = right;
do {
while (pivot < arr[_right]) {
_right--;
}
while (pivot > arr[_left]) {
_left++;
}
if (_left <= _right) {
if (_left != _right) {
int temp = arr[_left];
arr[_left] = arr[_right];
arr[_right] = temp;
}
_right--;
_left++;
}
} while (_right >= _left);
if (left < _right){
quickSort(arr, left, _right);
}
if (right > _left){
quickSort(arr, _left, right);
}
}</code></pre>
</noscript>
</div>
<h4 style="text-align: justify;"><span style="color: #ff9900;"><strong>#Geliştirilmiş Hızlı Sıralama(Enhanced Quick Sort)</strong></span></h4>
<p>Quick sort algoritmasında en kötü durum sonucunun ürettiği performans
düşüklüğünü göz önüne alınarak algoritmada değişikliğe
gidilmiştir.Bununla birlikte veri kümesinin 10'dan az elemana sahip
olduğu zamanlarda hızlı sıralama algoritmasının yerine <a href="http://blog.koseburak.net/insertion-sort/">direkt
yerleştirme sıralama</a>sının
uygulanması daha efektif olacaktır.</p>
<p>En kötü durumun oluşmasının nedeni pivot seçimidir.Pivot seçimi normal
şartlar altında dizinin orta noktası seçilerek gerçekleşiyordu.Bunun
yerine bu yaklaşımda pivot elemanı dizinin ortasındaki,başındaki ve
sonundaki elemanlar karşılaştırılarak seçilmesi şeklinde
düzenlenmiştir(bknz : median of three).Bu değişiklik hızlı sıralama
algoritmasının karmaşıklığını değiştirmeyecek fakat gerçekleştirilen
karşılaştırma sayısında azalma olacaktır.</p>
<div class="gist">
<script src='https://gist.github.com/6db3ad4e3893dc530408.js'></script>
<noscript>
<pre><code>public static void quickSort(int[] arr, int left, int right) {
if (right - left < 10) {
insertionSort(arr,left,right);
}
int pivot;
if (arr[right] > arr[left]) {
if (arr[(left + right) / 2] > arr[right]) {
pivot = arr[right];
} else if (arr[(left + right) / 2] > arr[left]) {
pivot = arr[(left + right) / 2];
} else {
pivot = arr[left];
}
}
else {
if (arr[(left + right) / 2] > arr[left]) {
pivot = arr[left];
} else if (arr[(left + right) / 2] > arr[right]) {
pivot = arr[(left + right) / 2];
} else {
pivot = arr[right];
}
}
int _left = left;
int _right = right;
do {
while (pivot < arr[_right]) {
_right--;
}
while (pivot > arr[_left]) {
_left++;
}
if (_left <= _right) {
if (_left != _right) {
int temp = arr[_left];
arr[_left] = arr[_right];
arr[_right] = temp;
}
_right--;
_left++;
}
} while (_right >= _left);
if (left < _right) {
quickSort(arr, left, _right);
}
if (right > _left) {
quickSort(arr, _left, right);
}
}</code></pre>
</noscript>
</div>
<h4><span style="color: #ff9900;">**#Yinelemeli Olmayan Hızlı Sıralama(Non-Recursive Quick Sort)</h4>
<p>**</span> {style="text-align: justify;"}</p>
<p>Özyinelemeli(recursion) yaklaşımdan zorunda kalmadığım müddetçe uzak
kalmaya çalışıyorum.Bazı zamanlar oldukça yorucu olabiliyor.Bu
algoritmayıda olumsuz yönde etkileyen bir etken özyinelemeli yaklaşım.</p>
<p>Stack kullanarak bu soruna bir alternatif yaklaşım üretebiliriz.Hızlı
sıralama algoritmasında fark edildiği gibi aslında çok önemli iki
parametre alıyor.Bunlar alt veri kümenin başlangıç ve bitiş
indisleri.Bunları ayrı bir veri yapısında tutarak şöyle bir çözüm
üretebiliriz.</p>
<div class="gist">
<script src='https://gist.github.com/7faa4e70c7c672ee2694.js'></script>
<noscript>
<pre><code>public static void quickSort(int[] arr) {
int subArray = 0;
Stack<Integer> stack = new Stack<Integer>();
stack.push(0); // left
stack.push(arr.length - 1); // right
do {
int right = stack.pop();
int left = stack.pop();
--subArray;
do {
int _left = left;
int _right = right;
int pivot = arr[(left + right) / 2];
do {
while (pivot < arr[_right]) {
_right--;
}
while (pivot > arr[_left]) {
_left++;
}
if (_left <= _right) {
if (_left != _right) {
int temp = arr[_left];
arr[_left] = arr[_right];
arr[_right] = temp;
}
_right--;
_left++;
}
} while (_right >= _left);
if (_left < right) {
++subArray;
stack.push(_left);
stack.push(right);
}
right = _right;
} while (left < right);
} while (subArray > -1);
}</code></pre>
</noscript>
</div>
<p>Yapılan değişiklikler algoritmanın karmaşıklığını etkilemediği için
çalışma zamanı karmaşıklığı değişmemektedir.</p>
<p>BURAK KÖSE</p>İlk iş kısa süreliler (Shortest Job First)2014-11-26T12:00:00+01:002014-11-26T12:00:00+01:00Buraktag:www.koseburak.net,2014-11-26:/blog/sjf/<p>Bir önceki yazımda cpu zamanlama algoritmalarından olan fcfs
algoritmasından bahsetmiştim.Asıl ismi "shortest next CPU burst
algorithm" olarak geçen ve yine bir cpu zamanlama algoritması olan
Shortest Job First(SJF) yani en kısa iş ilk algoritmasını inceleyelim.</p>
<p>Bu algoritmada belli bir sırada bekleyen işlerden önce kısa olanların
işlenmesi amaçlanmıştır.Eğer …</p><p>Bir önceki yazımda cpu zamanlama algoritmalarından olan fcfs
algoritmasından bahsetmiştim.Asıl ismi "shortest next CPU burst
algorithm" olarak geçen ve yine bir cpu zamanlama algoritması olan
Shortest Job First(SJF) yani en kısa iş ilk algoritmasını inceleyelim.</p>
<p>Bu algoritmada belli bir sırada bekleyen işlerden önce kısa olanların
işlenmesi amaçlanmıştır.Eğer iki işten aynı çalışma süresi içeren işler
varsa geliş sıralarına göre işlem görürler.Bu algoritmanın duruma göre
hem nonpreemptive(kesintisiz) hemde preemptive(kesintili) olarak
düzenlenebilir.</p>
<p>Temel olarak eldeki işlerin en kısasını yaparak zamandan kazanmaya
çalışan bir algoritma olsada en büyük dezavantajı bir çıkmaz
yaratmasıdır.Bu çıkmazı şöyle bir örnek ile açıklayabiliriz.</p>
<p>Bir berbere gidiyorsunuz ve berberde sıra var.Dolayısı ile sıra almanız
gerekiyor ve sıraya giriyorsunuz .Bu berberde işi kısa sürecek olan
kişilere hep öncelik tanınıyor.Dolayısı ile siz,işi sizden uzun
süreceklerin önüne geçiyorsunuz ve sıra size geliyor .İşiniz
hallediliyor tam siz berberden çıkarken yine işi kısa sürecek biri
geliyor ve sizin önünüze geçtiğiniz kişinin sırasını tekrar alıyor ve
bunun çalışma saatleri bitene kadar böyle devam ettiğini
düşünün.Dolayısı ile işi uzun ama çok önce gelmiş kişiler gün sonunda
işini halledememiş bir şekilde beklemeye devam ediyorlar.</p>
<p>Böyle bir kısır döngüye girme ihtimali bulunmaktadır.Şimdi
algoritmamızı nonpreemptive bir durum için şu örnek ile açıklamaya devam
edelim.</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Çalışma Zamanı</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">A</td>
<td style="text-align: center;">8</td>
</tr>
<tr>
<td style="text-align: center;">B</td>
<td style="text-align: center;">10</td>
</tr>
<tr>
<td style="text-align: center;">C</td>
<td style="text-align: center;">9</td>
</tr>
<tr>
<td style="text-align: center;">D</td>
<td style="text-align: center;">5</td>
</tr>
</tbody>
</table>
<p>ve sonuç olarak aşağıdaki gibi bir çalışma zamanı tablosu göreceğiz.</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Başlangıç Zamanı</th>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Çalışma Zamanı</th>
<th style="text-align: center;">Kalan Zaman</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">0</td>
<td style="text-align: center;">D</td>
<td style="text-align: center;">5</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">5</td>
<td style="text-align: center;">A</td>
<td style="text-align: center;">8</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">13</td>
<td style="text-align: center;">C</td>
<td style="text-align: center;">9</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">22</td>
<td style="text-align: center;">B</td>
<td style="text-align: center;">10</td>
<td style="text-align: center;">0</td>
</tr>
</tbody>
</table>
<p>Bu işlemler sonunda işlemlerin bekleme süreleri</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Çalışma Zamanı</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">A</td>
<td style="text-align: center;">5</td>
</tr>
<tr>
<td style="text-align: center;">B</td>
<td style="text-align: center;">22</td>
</tr>
<tr>
<td style="text-align: center;">C</td>
<td style="text-align: center;">13</td>
</tr>
<tr>
<td style="text-align: center;">D</td>
<td style="text-align: center;">0</td>
</tr>
</tbody>
</table>
<p>Yukarıdaki örnekde giren işlem kesintisiz bir şekilde
gerçekleşmiştir.Şimdi bu örneğimizde ise algoritmamızı preemptive bir
durum için inceleyelim.</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Geliş Zamanı</th>
<th style="text-align: center;">Çalışma Zamanı</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">A</td>
<td style="text-align: center;">0</td>
<td style="text-align: center;">10</td>
</tr>
<tr>
<td style="text-align: center;">B</td>
<td style="text-align: center;">1</td>
<td style="text-align: center;">6</td>
</tr>
<tr>
<td style="text-align: center;">C</td>
<td style="text-align: center;">2</td>
<td style="text-align: center;">11</td>
</tr>
<tr>
<td style="text-align: center;">D</td>
<td style="text-align: center;">3</td>
<td style="text-align: center;">7</td>
</tr>
</tbody>
</table>
<p>ve sonuç olarak aşağıdaki gibi bir çalışma zamanı tablosu göreceğiz.</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Başlangıç Zamanı</th>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Çalışma Zamanı</th>
<th style="text-align: center;">Kalan Zaman</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">0</td>
<td style="text-align: center;">A</td>
<td style="text-align: center;">1</td>
<td style="text-align: center;">9</td>
</tr>
<tr>
<td style="text-align: center;">1</td>
<td style="text-align: center;">B</td>
<td style="text-align: center;">6</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">7</td>
<td style="text-align: center;">D</td>
<td style="text-align: center;">7</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">14</td>
<td style="text-align: center;">A</td>
<td style="text-align: center;">9</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">23</td>
<td style="text-align: center;">C</td>
<td style="text-align: center;">11</td>
<td style="text-align: center;">0</td>
</tr>
</tbody>
</table>
<p>BURAK KÖSE</p>Selection Sort - Sıralama Algoritmaları2014-11-25T12:00:00+01:002014-11-25T12:00:00+01:00Buraktag:www.koseburak.net,2014-11-25:/blog/selection-sort/<p>Veri kümesinin sıralı olarak tutulması için geliştirilmiş en basit
sıralama algoritmalarındandır.Türkçe'de seçmeli sıralama , seçerek
sıralama şeklinde kullanılır.Geliştirilen uygulamalarda seçmeli sıralama
kullanmak için düzgün bir analiz yapılması gerekir.Yer değiştirme
sayısındaki sabitlik dolayısı ile büyük sayıda verinin bulunduğu uzun
dosyalarda lineer zamanda sıralama yapılabilir.</p>
<p>Temel olarak işleyiş şu şekilde …</p><p>Veri kümesinin sıralı olarak tutulması için geliştirilmiş en basit
sıralama algoritmalarındandır.Türkçe'de seçmeli sıralama , seçerek
sıralama şeklinde kullanılır.Geliştirilen uygulamalarda seçmeli sıralama
kullanmak için düzgün bir analiz yapılması gerekir.Yer değiştirme
sayısındaki sabitlik dolayısı ile büyük sayıda verinin bulunduğu uzun
dosyalarda lineer zamanda sıralama yapılabilir.</p>
<p>Temel olarak işleyiş şu şekilde gerçekleşir.İlk olarak veri kümesinin
ilk elemanı seçilir ve geri kalan veriler ile karşılaştırılarak en küçük
eleman bulunur ve kümenin başına yazılır.Daha sonra bir sonraki
elemanlar içinde aynı işlem yapılarak dizi sıralanana kadar n. adımda
tamamlanır.Aşağıdaki animasyon ile daha iyi anlayabiliriz.</p>
<p><center>
<img alt="Selection Sort" src="https://upload.wikimedia.org/wikipedia/commons/9/94/Selection-Sort-Animation.gif"><br>
<em>(Alıntı : wikipedia)</em>
</center></p>
<blockquote>
<p>Karmaşıklık analizi : O(n \^ 2)<br>
Karşılaştırma sayısı : n\^2 / 2<br>
Yer değiştirme sayısı : n (sabit)</p>
</blockquote>
<p><center>
<iframe width="560" height="315" src="//www.youtube.com/embed/Ns4TPTC8whw" frameborder="0" allowfullscreen></iframe>
</center></p>
<div class="gist">
<script src='https://gist.github.com/f90e31967b4d07aa8601.js'></script>
<noscript>
<pre><code>public void selectionSort(int[] arr){
for(int i = 0 ; i < arr.length - 1 ; i++){
int minPos = i;
for(int j = i+1 ; j < arr.length ; j++){
if(arr[j] < arr[minPos]){
min = j;
}
}
int temp = arr[i];
arr[i] = arr[minPos];
arr[minPos] = temp;
}
} </code></pre>
</noscript>
</div>
<p>BURAK KÖSE</p>Insertion Sort - Sıralama Algoritmaları2014-11-24T16:00:00+01:002014-11-24T16:00:00+01:00Buraktag:www.koseburak.net,2014-11-24:/blog/insertion-sort/<p>Uygulaması kolay olan bu algoritmayı büyük diziler yerine daha küçük
dizilerde kullanıldığında ve özellikle gelen veri kümesinin zaten
sıralanmış veya sıralanmış haline çok yakın olduğunda kullanılır.</p>
<p>Kararlı bir algoritma olmasıyla birlikle çalışma anında ek bir bellek
ihtiyacı duymayan bu algoritma Türkçe'da yerleştirmeli sıralama ,
eklemeli sıralama ve sokma sıralaması olarak adlandırılabilir …</p><p>Uygulaması kolay olan bu algoritmayı büyük diziler yerine daha küçük
dizilerde kullanıldığında ve özellikle gelen veri kümesinin zaten
sıralanmış veya sıralanmış haline çok yakın olduğunda kullanılır.</p>
<p>Kararlı bir algoritma olmasıyla birlikle çalışma anında ek bir bellek
ihtiyacı duymayan bu algoritma Türkçe'da yerleştirmeli sıralama ,
eklemeli sıralama ve sokma sıralaması olarak adlandırılabilir.</p>
<p>Algoritma sıralanacak olam veri kümesinin ikinci elemanından itibaren
verileri sırayla kontrol eder ve bir önceki kayıt o anki kayıttan
büyükse(veya küçükse sıralama tipine bağlı olarak) bu iki elemanın
yerleri değiştirilir ve geriye doğru kontrollere devam edilir.Dizi
elemanı doğru yere yerleştirilene kadar bu işlemler tekrar edilir.</p>
<p>Günlük hayatta aslında iskambil kağıtlarını sıralarken bu algoritmayı
kullanırız.Şimdi bu algoritmayı analiz edelim.</p>
<blockquote>
<blockquote>
<p>En iyi durumda (best case) : O(n)</p>
<blockquote>
<p>Dizi zaten sıralanmıştır<br>
Karşılaştırma sayısı : n(n-1)/2</p>
</blockquote>
<p>En kötü durumda(worst case) : O(n\^2)</p>
<blockquote>
<p>Dizi tersten sıralı<br>
Karşılaştırma sayısı : n(n-1)/2</p>
</blockquote>
</blockquote>
</blockquote>
<p>ve bu algoritmayı aşağıdaki şekilde tanımlayabiliriz.</p>
<div class="gist">
<script src='https://gist.github.com/8ad4a6c60d2cc51fe8d4.js'></script>
<noscript>
<pre><code>public void insertionSort(int[] arr){
fo(int i = 1 ; i < arr.length ; i++){
for(int j = i ; j > 0 ; j--){
if(arr[j] < arr[j-1]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}else{
break;
}
}
}
}</code></pre>
</noscript>
</div>
<iframe src="//www.youtube.com/embed/ROalU379l3U" width="560" height="315" frameborder="0" allowfullscreen="allowfullscreen"></iframe>
<h4 style="text-align: justify;"><span style="color: #ff9900;"><strong>#Direkt Yerleştirmeli Sıralama (Straight Insertion Sort)</strong></span></h4>
<p>Yukarıda bu algoritmanın günlük hayatta iskambil kağıtlarını sıralamak
için kullanıldığını söylemiştik.Aslında bu çok da doğru değildir.Bir
araya ekleme işlemi vardır fakat bu ekleme işlemi hiç bir zaman tek tek
kontrol yaparak ve yer değiştirerek olmayacaktır.Bir örnek verelim.</p>
<blockquote>
<p>2,4,1,5</p>
</blockquote>
<p>ve algoritmayı ilk adım için işletelim ve 4'ü seçelim bir işlem
yapılamayacaktır çünkü bu aşamada sıralıdır.Bir sonraki adım olarak 1'i
seçelim ve geriye doğru kotrollere devam edelim.</p>
<blockquote>
<p>1 \< 4 mü ?</p>
</blockquote>
<p>evet o halde 1'i araya al.Yeni durum <strong>"2,1,4,5"</strong></p>
<blockquote>
<p>1 \< 2 mi?</p>
</blockquote>
<p>evet o halde tekrar araya al.Yeni durum <strong>"1,2,4,5"</strong></p>
<p>şeklinde algoritma işleyecektir.Oysa biz gerçekte 2 ve 4 sıralı olduğu
için direk olarak 1'i en başa ekleyeceğiz.Yani her seferinde yer
değiştirme yapmayacağız sadece kaydırma işlemi yapacağız ve direkt
olarak yerleştirme yapacağız.</p>
<p>Şimdi bu yaklaşım ile insertion sort'un yeniden düzenlenmiş bir
algoritması olan <strong>Direkt Yerleştirmeli Sıralama ( Straight Insertion
Sort)</strong> algoritmasının inceleyelim.</p>
<blockquote>
<p>En kötü durumda(worst case) : O(n\^2)</p>
<blockquote>
<p>Dizi tersten sıralı<br>
Karşılaştırma sayısı : n\^2 / 2<br>
Yer değiştirme sayısı : n\^2 / 4</p>
</blockquote>
</blockquote>
<p>[gist:id=b9ee29a595a80d486622]<br>
Algoritmayı aşağıdaki animasyon ile daha iyi anlayabiliriz.</p>
<p><img alt="Insertion Sort" src="https://upload.wikimedia.org/wikipedia/commons/9/9c/Insertion-sort-example.gif"><br>
<em>(Alıntı : wikipedia)</em></p>
<h4><strong><span style="color: #ff9900;">#İkili Yerleştirmeli Sıralama(Binary Insertion Sort)</span></strong></h4>
<p>Şimdi biraz daha derine inerek bu algoritmanın daha optimize bir hale
getirilmiş hali olan ve daha büyük veri kümelerinde diğer yerleştirmeli
sıralama algoritmalarına göre daha başarılı olan bir algoritma olan
İkili Yerleştirmeli Sıralama algoritmasını inceleyelim.</p>
<p>Bu algoritmada seçilen dizi verisinin kendinden önce gelen veriler
arasında nereye yerleştirileceğine karar verilirken geriye doğru ardaşık
olarak kontrol etmek yerine , elimizdeki veri kümesine bir bütün olarak
bakılarak ikili arama yapılması amaçlanmıştır.Hedef yer belirlendikten
sonra tekrar kaydırma işlemi yapılarak işlem tamamlanır.</p>
<p>Karmaşıklık için.</p>
<blockquote>
<p>En kötü durumda(worst case) : O(nlogn)</p>
<blockquote>
<p>Dizi tersten sıralı<br>
Karşılaştırma sayısı : n(logn - nloge) (yaklaşık olarak)</p>
</blockquote>
</blockquote>
<div class="gist">
<script src='https://gist.github.com/6a568b504a36dedbc397.js'></script>
<noscript>
<pre><code>public void insertionSort(int[] arr){
for(int i = 1 ; i < arr.length ; i++){
int control = arr[i];
int down = 0;
int up = i;
while(down < up){
int mid = (down + up) / 2;
if(control < arr[mid]){
up = mid;
}else{
down = mid + 1 ;
}
}
for(int j = i ; j > down ; --j){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
} </code></pre>
</noscript>
</div>
<p>BURAK KÖSE</p>İlk gelen işi kapar (First Come First Serve)2014-11-24T01:05:00+01:002014-11-24T01:05:00+01:00Buraktag:www.koseburak.net,2014-11-24:/blog/first-come-first-serve/<p>Kısaca FCFS algoritması.İsim benzerliği ve aslında çalışma mantığı
bakımında kuyruk(queue) veri yapısına çok benzer(FIFO).Bilgisayar
alanında özellikle işletim sistemlerinde bir çok alanda kullanılan bir
algoritmadır.Bu algoritmik yaklaşımda bir sıraya ilk girenin işi ilk
halledilmektedir.</p>
<!--more-->
<p>Bu şu şekilde açıklanabilir.Mahallenizde bir berber bulunmaktadır fakat
ne yazık ki …</p><p>Kısaca FCFS algoritması.İsim benzerliği ve aslında çalışma mantığı
bakımında kuyruk(queue) veri yapısına çok benzer(FIFO).Bilgisayar
alanında özellikle işletim sistemlerinde bir çok alanda kullanılan bir
algoritmadır.Bu algoritmik yaklaşımda bir sıraya ilk girenin işi ilk
halledilmektedir.</p>
<!--more-->
<p>Bu şu şekilde açıklanabilir.Mahallenizde bir berber bulunmaktadır fakat
ne yazık ki berber doludur ve herkes sırasını beklemektedir.Sizde bir
sıra alırsınız ve aldığınız sırayı beklemek zorundasınızdır.Sizi önemli
kılan hiç bir (para,pul,şöhret,tanıdık...) sıranızı beklemekten
alıkoyamaz ve size sıra gelebilmesi için berberin sizden önce gelen tüm
müşteriler ile ilgilenmiş olması gerekmektedir .İşte bu algoritmada buna
benzer şekilde çalışır.</p>
<p>Şimdi bu algoritmayı CPU Scheduling yani işlemci zamanlama tarafından
örnekleyerek açıklayalım.Bu yaklaşımda işlemciye gelen işlerin
işlenmesi, işlemlerin geliş sırasına göre belirlenmektedir.</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Çalışma Zamanı</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">A</td>
<td style="text-align: center;">23</td>
</tr>
<tr>
<td style="text-align: center;">B</td>
<td style="text-align: center;">6</td>
</tr>
<tr>
<td style="text-align: center;">C</td>
<td style="text-align: center;">2</td>
</tr>
</tbody>
</table>
<p>ve sonuç olarak aşağıdaki gibi bir tablo göreceğiz.</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Başlangıç Zamanı</th>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Çalışma Zamanı</th>
<th style="text-align: center;">Kalan Zaman</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">0</td>
<td style="text-align: center;">A</td>
<td style="text-align: center;">23</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">23</td>
<td style="text-align: center;">B</td>
<td style="text-align: center;">6</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">29</td>
<td style="text-align: center;">C</td>
<td style="text-align: center;">2</td>
<td style="text-align: center;">0</td>
</tr>
</tbody>
</table>
<p>Bu algoritma sonunda işlemlerin bekleme süreleri</p>
<table>
<thead>
<tr>
<th style="text-align: center;">Process</th>
<th style="text-align: center;">Bekleme Süresi</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center;">A</td>
<td style="text-align: center;">0</td>
</tr>
<tr>
<td style="text-align: center;">B</td>
<td style="text-align: center;">23</td>
</tr>
<tr>
<td style="text-align: center;">C</td>
<td style="text-align: center;">29</td>
</tr>
</tbody>
</table>
<p>Dolayısı ile ortalama bekleme süresi = (0+23+29) / 3 = 17.3</p>
<p>First come first serve (FCFS) algoritması nonpreemptive(kesintisiz) bir
zamanlama algoritmasıdır.Yani sıraya giren işlemlerden biri bitirilmeden
diğer işleme geçilmemektedir.</p>
<p>Not : Eğer yukarıdaki processleri geliş sürelerine göre değilde çalışma
zamanlarına göre sıralayarak işleme alsaydık ortalama bekleme süresinin
daha az olduğunu görürdük.(bknz :SJF algoritması)</p>
<p>BURAK KÖSE</p>Bubble Sort - Sıralama Algoritmaları2014-11-23T14:19:00+01:002014-11-23T14:19:00+01:00Buraktag:www.koseburak.net,2014-11-23:/blog/bubble-sort/<p>Algoritma yazılarıma sıralama algoritmaları ile başlamak istedim.İlk
olarak bubble sort ile başlamayı düşünürken bundan bir süre önce
izlediğim bir video aklıma geldi.</p>
<p>Bu videoda Barack Obama'nın başkan seçilmeden önce Google'da yaptığı bir
konuşma geçiyor. Google CEO'su Eric Schmidt ile yaptığı sohbette
Obama'ya bir milyon adet 32-bit integer sayıyı sıralamak …</p><p>Algoritma yazılarıma sıralama algoritmaları ile başlamak istedim.İlk
olarak bubble sort ile başlamayı düşünürken bundan bir süre önce
izlediğim bir video aklıma geldi.</p>
<p>Bu videoda Barack Obama'nın başkan seçilmeden önce Google'da yaptığı bir
konuşma geçiyor. Google CEO'su Eric Schmidt ile yaptığı sohbette
Obama'ya bir milyon adet 32-bit integer sayıyı sıralamak için en efektif
yolun hangisi olduğu soruluyor.Obama biraz bocalayıp düşündükten sonra
Schmidt sorduğu soru için tam özür dileyerek yanıtlamayabilirsiniz
diyecekken Obama'dan kabarcık sıralamasının doğru olduğunu düşünmüyorum
cevabı gelince Schmidt şaşırarak Obama'nın bilgisayar bilimleriyle
ilgili bir geçmişinin olmadığını söylerek cevabı ona kimin söylediğini
soruyor.Tam bunun üzerine Obama</p>
<blockquote>
<p>"Bizim oradada casuslarımız var"</p>
</blockquote>
<p>diyerekten ince esipirisini yapıyor.Şimdi gelelim algoritmamıza.</p>
<p>Kabarcık sıralaması olarak geçen bu algoritma ilk olarak yer değiştirme
algoritması olarak adlandırılmıştır.Şimdilerde kabarcık sıralaması
olarak adlandırılmasının nedeni ise dizi içerisindeki elemanların
algoritmanın her anında dizi sonuna doğru ilerlemesidir(sıralama türüne
bağlı olarak).</p>
<p>Algoritmanın analizi :</p>
<blockquote>
<p>En iyi durum : O(n)</p>
<blockquote>
<p>-Dizi zaten sıralanmış<br>
-Yer değiştirme sayısı: 0<br>
-Karşılaştırma sayısı: n-1</p>
</blockquote>
<p>En kötü durum : O(n\^2)</p>
<blockquote>
<p>-Dizi tersten sıralı<br>
-Yer değiştirme sayısı: O(n\^2)<br>
-Karşılaştırma sayısı: O(n\^2 /2)</p>
</blockquote>
<p>Ortalama durum : 0(n\^2)</p>
<blockquote>
<p>-Bütün olasılıklar kontrol edilir</p>
</blockquote>
</blockquote>
<p>Dolayısı ile bu algoritmanın en kötü durumdaki çalışma zamanı
O(n\^2)'dir,algoritmanın en kötü durumda yapacağı karşılaştırma sayısı
O(n\^2 / 2)'dir ve yer karmaşıklığı O(n)'dir.</p>
<p>Örneğin küçükten büyüğe doğru sıralanacak bir işlem için algoritma şu
adımlarda gerçekleşir.Dizinin başından başlanılarak dizi elemanları
sırayle gezilir , gezilen dizi elemanları kendinden sonra gelecek eleman
ile sıralama türüne bağlı olarak(küçüten büyüğe gibi) kontrol edilir ve
yer değiştirilir.Bu işlem dizi sonuna kadar devam eder.</p>
<p>Bir örnek verelim</p>
<blockquote>
<p>7 , 9 , 4 , 11 , 8 , 3 , 5</p>
</blockquote>
<p>Bu algoritmanın adımları şu şekilde olacaktır.</p>
<blockquote>
<p>1. adım: 7 , 4 , 9 , 8 , 3 , 5 , 11</p>
<p>2. adım: 4 , 7 , 8 , 5 , 7 , 9 , 11</p>
<p>3. adım: 4 , 7 , 3 , 5 , 8 , 9 , 11</p>
<p>4. adım: 4 , 3 , 5 , 7 , 8 , 9 , 11</p>
<p>5. adım: 3 , 4 , 5 , 7 , 8 , 9 , 11</p>
<p>6. adım: 3 , 4 , 5 , 7 , 8 , 9 , 11</p>
</blockquote>
<p>gibi bir sonuç elde edilir.Yani kısaca şöyle bir işlem yapılıyor , iki
sayı alıyor bu iki sayıyı küçükten büyüğe sıralanacak şekilde yer
değitiriliyor ve bu işlem dizi bitene kadar tekrarlanıyor.Alttaki
animasyon anlamaya yardımcı olacaktır.</p>
<p><img alt="Bubble-sort-example-300px" src="//upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif">
<em>(Alıntı : wikipedia)</em></p>
<p>Kabarcık sıralaması çok da verimli olmayan bir sıralama algoritmasıdır
fakat bazı basit müdahaleler ile biraz daha efektif hale
getirilebilir.Bu konuda yazılarımı sıralama algoritmalarını temel olarak
inceledikten sonra yayınlayacağım bir yazıdan ulaşabilirsiniz.</p>
<div class="gist">
<script src='https://gist.github.com/e26eaa1f57a84afa5273.js'></script>
<noscript>
<pre><code>public void bubbleSort(int[] arr)
{
int temp;
for(int i=1; i<arr.length; i++)
{
for(int j=0; j<arr.length-i; j++)
{
if(arr[j] > arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}</code></pre>
</noscript>
</div>
<p>Obama ve Eric Schdimit konuşması için : </p>
<iframe src="//www.youtube.com/embed/k4RRi_ntQc8" width="420" height="315" frameborder="0" allowfullscreen="allowfullscreen"></iframe>
<p>Bubble sort için eğlenceli bir anlatım: </p>
<iframe src="//www.youtube.com/embed/lyZQPjUT5B4" width="560" height="315" frameborder="0" allowfullscreen="allowfullscreen"></iframe>
<p>BURAK KÖSE</p>Arch Linux Nasıl Kurulur2014-11-12T18:45:00+01:002014-11-12T18:45:00+01:00Buraktag:www.koseburak.net,2014-11-12:/blog/arch-linux-kurulumu/<p><em>Bu yazı Arch Linux 2014 Ağustos kalıbı dikkate alınarak
hazırlanmıştır.</em></p>
<p><strong>Neden Arch , Nedir Bu ?</strong></p>
<p>Arch Linux "sürekli güncel"(bkz: "rolling release") paket mantığı
üzerine kurulu, belirli bir düzeyde GNU/Linux bilgisi olan kullanıcıları
hedef alan(tamamen göreceli kimileri yeni başlayanlar için ideal olduğu
görüşünde) bağımsız bir dağıtımdır.Arch hızlı, hafif …</p><p><em>Bu yazı Arch Linux 2014 Ağustos kalıbı dikkate alınarak
hazırlanmıştır.</em></p>
<p><strong>Neden Arch , Nedir Bu ?</strong></p>
<p>Arch Linux "sürekli güncel"(bkz: "rolling release") paket mantığı
üzerine kurulu, belirli bir düzeyde GNU/Linux bilgisi olan kullanıcıları
hedef alan(tamamen göreceli kimileri yeni başlayanlar için ideal olduğu
görüşünde) bağımsız bir dağıtımdır.Arch hızlı, hafif, esnek ve basittir.</p>
<p>Arch Linux temel sistemi olabildiğince ufaktır.Çeşitli
işlemlerin yapılması kullanıcıya bırakılmıştır.Kullanıcı istediği
doğrultuda zengin depo yardımıyla istediği şekilde kendine uygun şekle
getirebilir.Kısacası kendi evinizi istediğiniz şekilde
biçimlendiriyorsunuz.</p>
<p><strong>Kurulum</strong></p>
<p>Kurulum aşaması metin tabanlı gerçekleşmektedir.Dolayısı ile komutlar
ile kurulum yapılmaktadır.Arch Linux'un dökümantasyonu çok
gelişmiştir.Sadece kurulum aşamasında değil çoğu zaman karşılaştığınız
sorunların çok büyük bir bölümüne buradan çözüm bulabilirsiniz.</p>
<p><a href="https://wiki.archlinux.org/">https://wiki.archlinux.org/</a><br>
<a href="http://archtr.org/wiki/index.php/Ana_Sayfa">http://archtr.org/wiki/index.php/Ana_Sayfa</a></p>
<p>Donanımım</p>
<blockquote>
<p>CPU: 64 bit Intel<br>
Hard Drive: 500GB HDD<br>
RAM: 8GB<br>
Intel Graphic Card<br>
Nvidia GTX 660M<br>
BIOS</p>
</blockquote>
<p><strong>Kuruluma Hazırlık Aşaması</strong></p>
<p>Arch Linux'un elde edilmesi için bu adres üzerinden kalıba
ulaşabilirsiniz.</p>
<p><a href="https://www.archlinux.org/download/">https://www.archlinux.org/download/</a></p>
<p>CD veya USB üzerinden kurulumu gerçekleştirebilirsiniz.İndirdiğiniz
kalıbı bu ortamlara yazarak bir sonraki aşamaya geçelim ve kurulum
yapacağınız birimi boot ettiğimizde karşılaşacağımız ekran aşağıdaki
gibi olacaktır.</p>
<p><img alt="Karşılaşılan Ekran" src="/images/arch_linux/arch-linux-install-001.jpg">]</p>
<h3 style="text-align: justify;"><strong>Aşama#1 <a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Establish_an_internet_connection">Arch Kurulumu</a></strong></h3>
<p>Kurulum aşamsında internet bağlantımız olması gerekmektedir.Dolayısı ile
benim önerim ethernet bağlantısı sağlamanız yönünde.Eğer kurulum
sırasında kablosuz bağlantı kullanacaksanız tebrikler ilk kez arch
wiki'yi kullanacaksınız demektir.</p>
<p>İlk olarak türkçe klavye kullanmak için</p>
<p><code># loadkeys trq</code></p>
<p>komutunu veriniz.Bağlantı kontrolunuz için</p>
<p><code># ping -c 3 www.google.com</code></p>
<p>Komutunun ekran çıksını size yol gösterecektir.Eğer her şey yolunda ise
bir sonraki adıma geçebilirsiniz.</p>
<h3 style="text-align: justify;"><strong>Aşama#2 <a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Prepare_the_storage_drive">Disk Bölümleme</a></strong></h3>
<p>Bu aşamada çok dikkatli olmasılısınz.Yanlış bir adım sizi veri kaybına
ve belkide delirmenize yol açabilir.Bu aşamayı elle gerçekleyeceğiniz
için önceden kendinize göre plan yaparak bölümleme işlemine geçiniz.</p>
<p>Bölümlendirme aşamasında temel olarak genellikle dört bölüm
yaratılır.Bunlar boot , / ( Kök dizini) , home ve swap alanlarıdır.Ben
şahsen tek bölüm yaratıp o şekilde kullanmayı tercih ediyorum sizde
yedekleme için kullandığınız ayrı bir disk bölümü varsa home dizini
oluşturmanıza gerek yoktur.Swap alanı ise RAM'e bağlıdır.Eğer 4GB ve
üstü RAM kullanıyorsanız bu alanada ihtiyacınız yoktur.</p>
<ul>
<li>/boot için = 100 MB</li>
<li>Swap ( Takas alanı) için = 2 GB</li>
<li>/ kök için = 20-25 GB</li>
<li>home için ise kişisel olarak oluşturmak istediğiniz miktarı
verebilirsiniz</li>
</ul>
<p>İlk olarak lsblk komutunu çalıştırarak daha önceden olan
bölümlemelerinizi kontrol edin ve bu aşamadan sonra tek bir disk
kullandığınızı varsayarak</p>
<p><code># cfdisk dev/sda</code></p>
<p>komutu sonrası görüntünüz şu şekilde olacaktır.</p>
<p><img alt="Disk Bölümleme" src="/images/arch_linux/Selection_024.png"></p>
<p>Temel olarak bölüm ayırırken boş alan seçiliyken "New - > Alan
boyutu - > Tamam" şeklinde bir yol izleyeceğiz.Şimdi alanları ayırmaya
başlayalım ve ilk olarak boot alanı ayıralım.</p>
<ol>
<li>/boot için 100 MB bölüm oluşturmak için New seçin ve alan oluştuktan
sonra alt tarafdaki özelliklerden Bootable özelliği verdikten sonra
Type kısmına 83 yazarak bir sonraki alana geçin.</li>
<li>Swap (takas) alanı için bölüm oluşturulmalıdır. Ben 2GB ayırdım.
Sizde kendinize göre ayırabilirsiniz. Type kısmına 82 yazdıktan
sonra bir sonraki alana geçin.</li>
<li>Kök ( / ) için bölüm oluşturulacaktır.Kök dizini için 20-25 GB kadar
alan ayırın. Type kısmına 83 yazın.</li>
<li>Aynı yol ile isteğiniz doğrultusunda home için dilediğiniz kadar
alan ayırdıktan sonra alt tarafdan Write kullanarak oluşturduğunuz
bölümleri yazın ve bir sonraki aşama için Quit ile çıkın.</li>
</ol>
<p><code># lsblk</code></p>
<p>komutu ile kontrol edelim.</p>
<blockquote>
<p>sda1 – BIOS Boot<br>
sda2 – root<br>
sda3 – swap<br>
sda4 – home</p>
</blockquote>
<p>tabiki sizde durum farklı olabilir.Bu aşamadan sonrada sizdeki duruma
göre şekil veriniz.</p>
<h3 style="text-align: justify;"><strong>Aşama#3 <a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Create_filesystems">Dosya Sistemlerini Oluşturma</a></strong></h3>
<p>Şimdi sırada oluşturduğumuz parçalara şekil vermeye geldi.Linux dosya
sistemi olarak ext4 kullanır.İlk olarak aşağıdaki komutları root ve home
dizinleri için yürütün.Bendeki şekli ile şu şekilde olacaktır.</p>
<p><code># mkfs.ext4 /dev/sda2</code><br>
<code># mkfs.ext4 /dev/sda4</code></p>
<p>Şimdi swap bölümümüz için bendeki şekli ile</p>
<p><code># mkswap /dev/sda3</code><br>
<code># swapon /dev/sda3</code></p>
<p>ve bu aşamanın son kısmı olarak son kez kontrol edelim bir sorun yoksa
diğer aşamaya geçebiliriz</p>
<p><code># lsblk /dev/sda</code></p>
<p><strong><a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Install_the_base_system">Temel Sistem
Kurulumu</a></strong></p>
<p>Her şey yerli yerinde ise sırada temel sistem kurulumumuz
bulunmaktadır.Öncelikle kök dizinimizi bağlayalım.</p>
<p><code># mount /dev/sda2 /mnt</code></p>
<p>ve "home" isimli bir klasör yaratalım.Evet home için oluşturduğumuz
parçayıda buraya bağlayacağız.</p>
<p><code># mkdir /mnt/home</code><br>
<code># mount /dev/sda4 /mnt/home</code></p>
<h3 style="text-align: justify;"><strong>Aşama#4 Temel paketlerin Kurulumu</strong></h3>
<p>Sırada sistemimizin temelini kurma aşamamız var.Bu aşamada iskelet
oluşacaktır.</p>
<p><code># pacstrap -i /mnt base base-devel</code></p>
<h3 style="text-align: justify;"><strong>Aşama#5 <a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Generate_an_fstab">fstab Güncelleme</a></strong></h3>
<p>Tüm temel paketlerin kurulumu başarı ile gerçekleştiyse fstab'a tüm
değişiklikleri bildirebiliriz.</p>
<p><code># genfstab -U -p /mnt >> /mnt/etc/fstab</code><br>
(Not:Kesinlikle bir problem ile karşılaşmamış olmamız gerekmektedir)</p>
<p>Linux'da her zaman yap kontrol et mekanizması işlemektedir.Bizde
yaptığımız değişikliği kontrol edelim.</p>
<p><code># nano /mnt/etc/fstab</code></p>
<p>Bir problem gözükmüyorsa CTRL + X ile çıkış yapabiliriz.</p>
<p>Bu aşamalarda bir problem ile karşılaşmadıysak root ve home dizinlerinin
başarı ile bağlanmış olduğunu görebiliriz.Kök dizinimizi değiştirerek
diskte kurduğumuz temel sisteme bürünelim.</p>
<p><code># arch-chroot /mnt ve bin/bash</code></p>
<h3 style="text-align: justify;"><strong>Aşama#6 <a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Chroot_and_configure_the_base_system">Dil ve Bölge ayarları</a></strong></h3>
<p>Ayarlarımız için sırası ile</p>
<p><code>#nano /etc/locale.conf</code><br>
açılan dosyaya</p>
<blockquote>
<p>LANG=tr_TR.UTF-8</p>
</blockquote>
<p>yazıp CTRL + O ile kayıt edip CTRL + X ile çıkalım.</p>
<p><code># nano /etc/vconsole.conf</code><br>
açılan dosyaya</p>
<blockquote>
<p>KEYMAP=trq<br>
FONT=iso09,16</p>
</blockquote>
<p>yazarak aynı şekilde kaydedip çıkalım.</p>
<p><code># nano /etc/timezone</code></p>
<blockquote>
<p>Europe/Istabul</p>
</blockquote>
<p>yazıp aynı şekilde kayıt edip çıkalım ve yaptığımız dil değişikliğini
yazmak için</p>
<p><code># locale-gen</code></p>
<p>Hostname değiştirmek için</p>
<p><code># echo ... > /etc/hostname</code><br>
(Not : ... olan yere dilediğinizi yazınız)</p>
<h3 style="text-align: justify;"><strong>Aşama#7 Depo Ayarları</strong></h3>
<p>Sırada depomuzu ayarlamaya geldik."pacman.conf" dosyamızı açalım</p>
<p><code># nano /etc/pacman.conf</code></p>
<p>Eğer 64 bit sistem kullanıyorsak</p>
<blockquote>
<p>[multilib]<br>
Include = /etc/pacman.d/mirrorlist</p>
</blockquote>
<p>bu kısmı aktif etmemiz gerkeiyor.Başındaki # işaretini kaldırmanız
yeterlidir.Daha sonra CTRL + O ile kayıt edip CTRL+X ile çıkalım.</p>
<p><code># pacman -Sy</code><br>
ile depoyu güncelleyelim.</p>
<h3 style="text-align: justify;"><strong>Aşama#8 <a href="https://wiki.archlinux.org/index.php/Users_and_Groups#User_management">Kullanıcı işlemleri</a></strong></h3>
<p>Kullanıcı işlemlerine geçmeden önce bir root şifresi atayalım.Bunu
kesinlikle yapmalısınız.Linux kullanırken root ile işlem yapmamaya
dikkat edin.Dolayısı ile root kullanıcısından başka bir sistemi
kullanacağınız bir kullanıcı oluşturacağız fakat ilk olarak root
şifresi...</p>
<p><code># passwd</code></p>
<p>komutunu yürüttükten sonra root kullanıcısına şifre atayınız.Tamamdır
şimdi sırada kullanıcı oluşturma var.</p>
<p><code># useradd -m -g users -G wheel,storage,power -s /bin/bash ...</code><br>
(Not: ... yerine kullanıcı adınızı giriniz)</p>
<p>ve daha sonra</p>
<p><code># passwd ...</code><br>
(Not: ... yerinde yukarıda oluşturduğunuz kullanıcı adı olacak)</p>
<p>ile bu kullanıcıya bir şifre atamalıyız.Sırada sudo kurulumu var.Bu bize
root olmadan sistem üzerinde işlemler yapmamıza olanak sağlayacak</p>
<p><code># pacman -S sudo</code></p>
<p>daha sonra kişisel önerim olarak</p>
<p><code># pacman -S bash-completion</code></p>
<p>kurulumu yapınız.Adındanda anlaşılacağı gibi otomatik tamamlamalarda
yardımcı olur.</p>
<h3 style="text-align: justify;"><strong>Aşama#9 Linux çekirdeğini derleme</strong></h3>
<p>Bu aşamada kernel konfigirasyonunu tamamlamak ve yazmak için aşağıdaki
komutu yürütün.</p>
<p><code>#mkinitcpio -p linux</code></p>
<h3 style="text-align: justify;"><strong>Aşama#10 <a href="https://wiki.archlinux.org/index.php/Boot_Loaders">Boot yükleyicisi</a></strong></h3>
<p>Bu aşamada grub kurulumu yapmalıyız.</p>
<p><code># pacman -S grub # grub-install --recheck /dev/sda</code></p>
<p>grub kurulumumuz tamamdır eğer sistemde birden fazla işletim sistemi
yüklüyse diğerlerinin algılanması için</p>
<p><code>#pacman -S os-prober</code></p>
<p>komutunu yürütelim.Şimdi grubu güncelleyelim.</p>
<p><code># grub-mkconfig -o /boot/grub/grub.cfg</code></p>
<p>ve sistem açılışında bağlantı alabilmemiz için</p>
<p><code># systemctl enable dhcpcd.service</code><br>
<code># systemctl start dhcpcd.service</code></p>
<p>sonrasında</p>
<p><code># exit</code><br>
<code># umount -R /mnt</code><br>
<code># reboot</code></p>
<p>komutlarını yürüttükten sonra sistem yeniden başlayacaktır.(Not: Yükleme
yaptığınız birimi(CD,USB...) çıkartınız.</p>
<h3 style="text-align: justify;"><strong>Aşama#11 Boot sonrası</strong></h3>
<p>Bir sorun yoksa karşınızda Arch Linux sizi selamlamalıdır.Basit kurulum
bitmiş olup kurulum sonrası yapılandırma aşamasına geçmiş
bulunmaktayız.Bundan sonraki yapılandırmalar size kalmış olsada basit
olarak temel bir yapılandırma olarak şunları yapabilirsiniz.Unutmayın
archwiki en yakın dostunuz.</p>
<p><strong>X server Kurulumu</strong><br>
<code># pacman -S xorg-server xorg-server-utils xorg-xinit</code></p>
<p><strong>Mesa Kurulumu</strong></p>
<p><code># pacman -S mesa</code></p>
<p>Şimdi sırada ekran kartı kurulumu bulunmaktadır.Bu aşama genelde
kullanıcıların başına bela açan bir aşamadır(Bende dahil).Eğer
sisteminizde optimus teklonojili bir ekran kartınız varsa yani çift
ekran kartlıysanız sizi burada hiç oyalamadan Arch Linux Wiki sayfasına
yönlendireceğim.Yapmanız gerekenler orada harika bir şekilde anlatılmış
olup tüm adımları dikkatlice adım adım izlemelisiniz.</p>
<p><a href="http://archtr.org/wiki/index.php?title=Bumblebee">http://archtr.org/wiki/index.php?title=Bumblebee</a><br>
<a href="https://wiki.archlinux.org/index.php/NVIDIA_Optimus">https://wiki.archlinux.org/index.php/NVIDIA_Optimus</a><br>
<a href="https://wiki.archlinux.org/index.php/bumblebee">https://wiki.archlinux.org/index.php/bumblebee</a></p>
<p>Eğer normal ekran kartı kullanıcısıysanız bile bu aşamada Arch Wiki'den
yardım alabilirsiniz.Kendinize uygun seçeneği kurun.Ben şu şekilde devam
ediyorum.</p>
<p><code># pacman -S nvidia</code></p>
<p><code># pacman -S xf86-video-intel</code></p>
<p><code># pacman -S xf86-video-ati</code></p>
<p><img alt="graphicsdoc.jpg" src="/images/arch_linux/graphicsdoc.jpg"></p>
<p>Eğer laptop kullanıcısıysanız</p>
<p><code># pacman -S xf86-input-synaptics</code></p>
<p>daha sonrasında temel x server bileşenleri için</p>
<p><code># pacman -S xorg-twm xorg-xclock xterm</code></p>
<p>ve test etmek için sistemi yeniden başlatıp</p>
<p><code>#startx</code></p>
<p>Her şey yolunda ise devam edebilirsiniz lakin değilse muhtemelen ekran
kartı kısmında bir yanlışlık yaptınız demektir.Arch wiki'den destek
alabilirsiniz.</p>
<p><strong>Ses sürücüsü için</strong></p>
<p><code># pacman -S alsa-lib alsa-utils</code></p>
<p><strong>Dbus Kurulumu</strong></p>
<p><code># pacman -S dbus</code></p>
<p><strong>Gamin Kurulumu</strong></p>
<p><code># pacman -S gamin</code></p>
<h3 style="text-align: justify;"><strong>Aşama#12 Masaüstü Kurulumu</strong></h3>
<p><strong>Kde Masaüstü Kurulumu:</strong></p>
<p>Uçbirimden devam ediyoruz.</p>
<p><code># pacman -S kde kde-l10n-tr</code></p>
<p>komutunu uygulayın</p>
<p><strong>Gnome Masaüstü Kurulumu:</strong></p>
<p><code># pacman -S gnome</code></p>
<p>Yükleme bittikten sonra tekrardan</p>
<p><code># pacman -S gnome-extra</code><br>
<code># pacman -S gnome-tweak-tool</code></p>
<p><strong>Cinnamon Kurulumu</strong></p>
<p><code># pacman -S cinnamon</code></p>
<p>komutunu uygulayıp soruları (Y) ile onaylayın.Eğer yukarıdaki örnekler
dışında kurmak istediğiniz bir masaüstü varsa siz istediğinizi
kurabilirisiniz.</p>
<p>Açılışta aktif etmek için aşağıdakilerden hangisi size uygunsa onu
yürütün.</p>
<p><code># systemctl enable gdm.service # systemctl enable kdm.service # systemctl enable lxdm.service # systemctl enable slim.service # systemctl enable xdm.service</code></p>
<p><strong>Firefox</strong> için</p>
<p><code>#pacman -S firefox</code></p>
<h3 style="text-align: justify;"><strong>Aşama#13 <a href="https://wiki.archlinux.org/index.php/Beginners%27_Guide#Configure_the_network">Ağ</a></strong></h3>
<p><code># pacman -S networkmanager</code></p>
<p>arayüz için</p>
<p><code># pacman -S kdeplasma-applets-plasma-nm</code></p>
<p>ve</p>
<p><code># systemctl enable NetworkManager</code><br>
<code># systemctl start NetworkManager</code></p>
<p>Ben kablosuz ağ kullanmak için yaptığımız aşamalarda nedenini bilmediğim
bir sorun ile karşılaştım.Bu sorunun çözümü için</p>
<p><code># systemctl disable dhcpcd.service</code></p>
<p>komutu ile çözdüm.</p>
<p>ve son , artık gönül rahatlığı ile Arch Linux kullanabilirsiniz ,
unutmayın baş ucu kaynağı olarak Arch Wiki vazgeçilmeziniz olsun.</p>
<p>Umarım işinize yarayan bir yazı olmuştur.</p>
<p>BURAK KÖSE</p>