Advent of Code 2025: 5. Günden Örnek Bir Optimizasyon Çözümü

Advent of Code yarışmasının 2025 yılı etkinliği, algoritma geliştiricilerin yeteneklerini test etmeye devam ediyor. 5. günde karşılaşılan problem, verimlilik ve optimizasyon üzerine odaklanmayı gerektiriyordu. Brute-force yönteminden başlayıp, daha akıllı çözümlere doğru ilerleyen bir hikaye, hem kodlama pratiğine hem de problem çözme stratejilerine ışık tutuyor.

Brute-Force Yaklaşımından Daha İyisine Doğru

Bir brute-force algoritması genellikle basit ve doğrudandır. Örneğin, verilen bir dizi numarayı belirli aralıklarla karşılaştırmak için tüm kombinasyonları tek tek denemek gerekebilir. Bu yöntem, küçük veri kümeleri için etkili olsa da, daha büyük veri setlerinde performans sorunlarına yol açabilir.

Problemde, 1000 adet bileşen kimliği ve neredeyse 200 adet aralık bulunuyordu. Brute-force yaklaşımıyla, her kimlik için tüm aralıkları kontrol etmek, en kötü senaryoda 200.000 işlem gerektirecekti. Bu, milisaniyeler içinde tamamlanabilecek bir süreç olsa da, daha verimli bir yöntem bulmak her zaman cazip olur.

Ancak, brute-force yönteminin basitliği ve doğruluğu, başlangıçta güven vericiydi. Yine de, algoritmanın performansını artırmak için daha akıllı bir yol aramak gerekiyordu.

Sıralamanın Gücü: Basit Bir Optimizasyon Adımı

Sıralama, algoritmaları optimize etmek için sıkça kullanılan bir tekniktir. Hem bileşen kimliklerini hem de aralıkları sıralamak, arama işlemlerini önemli ölçüde hızlandırabilir. Sıralı bir listenin avantajı, ikili arama gibi tekniklerle daha hızlı erişim sağlamasıdır.

Bu problemde, iki ana strateji uygulanabilirdi:

• Bileşen kimliklerini artan düzende sıralamak
• Aralıkları, alt sınırlarına göre artan düzende sıralamak

Bu yaklaşımın temel avantajı, her kimliği incelemek yerine, sadece ilgili aralıklarda arama yapmaktı. Böylece, 1000 kimlik yerine sadece 200 aralık üzerinde çalışarak, işlem sayısını önemli ölçüde azaltmak mümkün oldu. Bu, performans açısından hem zaman hem de kaynak tasarrufu sağladı.

Algoritmanın Uygulanması: Veri Hazırlığı ve İşlem

Algoritmanın ilk adımı, giriş verilerini doğru bir şekilde parse etmek ve sıralamaktı. Giriş verileri, iki bölümden oluşuyordu: birincisi aralıkları, ikincisi ise bileşen kimliklerini içeriyordu. Bu veriler, aşağıdaki adımlarla işlendi:

let [aralıklar, kimlikler] = giriş.split('\n\n');

aralıklar = aralıklar
  .split('\n')
  .map(str => str.split('-').map(Number))
  .sort((a, b) => a[0] - b[0]);

kimlikler = kimlikler
  .split('\n')
  .map(Number)
  .sort((a, b) => a - b);

Bu kod bloğunda, giriş verileri önce split yöntemiyle ayırıldı. Sonrasında, her bir parça sayıya dönüştürüldü ve ilgili listeler sıralandı. Bu sayede, hem aralıklar hem de kimlikler artan düzende organize edildi.

Ardından, her bir aralık için, ilgili kimlikleri filtrelemek ve eşleşenleri saymak gerekiyordu. Bu işlem, reduce ve filter fonksiyonları kullanılarak gerçekleştirildi:

let eşleşenSayacı = aralıklar.reduce((sayac, aralık) => {
  let eşleşenler = kimlikler.filter(el => el >= aralık[0] && el <= aralık[1]);
  kimlikler.splice(kimlikler.indexOf(eşleşenler[0]), eşleşenler.length);
  sayac += eşleşenler.length;
  return sayac;
}, 0);

Bu yaklaşım, her bir aralık için sadece gerekli kimlikleri kontrol etmeyi sağladı ve gereksiz işlemleri ortadan kaldırdı. Sonuç olarak, algoritma hem hızlı hem de doğru bir şekilde çalıştı.

İkinci Kısmın Zorluğu: Aralıkları Birleştirmek

İkinci kısımda, problem daha da karmaşık hale geldi. Artık, tüm aralıkların içinde yer alan tüm sayıları saymak gerekiyordu. Bu, brute-force bir yaklaşımla imkansız olmasa da, çok fazla bellek ve işlem gücü gerektirecekti.

Ancak, verilerin zaten sıralı olması, bu problemi çözmek için yeni bir yol sundu. Aralıkları birleştirerek, toplam sayıyı hesaplamak mümkün hale geldi. Bu yaklaşım, verimliliği artırmanın yanı sıra, bellek kullanımını da optimize etti.

Algoritma, aşağıdaki adımlarla uygulandı:

let bölüm2 = [];
bölüm2.push(aralıklar.splice(0, 1).flat());

aralıklar.forEach(aralık => {
  if (aralık[0] <= bölüm2[bölüm2.length - 1][1]) {
    bölüm2[bölüm2.length - 1][1] = aralık[1];
  } else {
    bölüm2.push(aralık);
  }
});

let toplamSayı = bölüm2.reduce((toplam, aralık) => {
  toplam += aralık[1] - aralık[0] + 1;
  return toplam;
}, 0);

Bu kod, aralıkları birleştirerek ve ardından toplam sayıyı hesaplayarak, problemi verimli bir şekilde çözmeyi sağladı. Her bir aralık için, alt sınırdan üst sınıra kadar olan tüm sayıları saymak yerine, sadece aralıkların birleştirilmiş hallerini kullanarak hesaplama yapıldı.

Deneyimlerden Çıkarılan Dersler ve Gelecek Adımlar

Advent of Code yarışması, geliştiricilerin hem algoritma tasarımındaki yeteneklerini hem de kodlama becerilerini test etmelerine olanak tanıyor. Bu yılın 5. günü, verimlilik ve optimizasyon konularında derinlemesine bir anlayış geliştirmek için mükemmel bir fırsat sundu.

Sıralama ve aralık birleştirme gibi teknikler, büyük veri setleriyle çalışırken performansı önemli ölçüde artırabilir. Bu tür yaklaşımlar, sadece yarışmalarda değil, gerçek dünya uygulamalarında da büyük değer sağlar. Gelecekteki projelerde bu teknikleri kullanmak, hem kodun hem de sistemin daha verimli çalışmasını sağlayacaktır.