Mülakat hazırlığı: Python soruları, algoritmalar, canlı kodlama

Derinleş: eksik kalan beş kalıp

Ders boyunca sözlük, küme, kayan pencere, iki pointer, ikili arama ve BFS kalıplarını gördün. Mülakat sorularının geri kalanının çoğu beş kalıba daha iner: yığın (stack), yığın-kuyruk (heap), önek toplamı (prefix sum), dinamik programlama (dynamic programming) ve geri izleme (backtracking). Bunlara aralık birleştirme ve LRU önbellek gibi "tasarım" sorularını eklersen klasik soru havuzunun büyük bölümünü kapsamış olursun. Özyinelemenin (recursion) temelini "Özyineleme" dersinde, sıralama algoritmalarının içini "Algoritmalar" dersinde gördün; burada mülakat açısından bakıyoruz.

1. Yığın: son giren ilk çıkar

Parantez doğrulama en klasik yığın sorusudur. Bir adım ötesi monoton yığındır: "her gün için fiyatın kaç gün sonra yükseleceğini bul" gibi sorularda, henüz cevabı bulunmamış günlerin indekslerini azalan sırada yığında tutarsın. Her indeks bir kez girip bir kez çıktığı için toplam O(n) olur.

def gecerli_mi(ifade):
    eslesme = {")": "(", "]": "[", "}": "{"}
    yigin = []
    for c in ifade:
        if c in "([{":
            yigin.append(c)
        elif c in eslesme:
            if not yigin or yigin.pop() != eslesme[c]:
                return False
    return not yigin

print(gecerli_mi("{[()()]}"), gecerli_mi("([)]"), gecerli_mi("(("))

def kac_gun_sonra(fiyat):
    sonuc = [0] * len(fiyat)
    yigin = []                          # cevabı bekleyen günlerin indeksleri
    for i, f in enumerate(fiyat):
        while yigin and fiyat[yigin[-1]] < f:
            j = yigin.pop()
            sonuc[j] = i - j
        yigin.append(i)
    return sonuc

print(kac_gun_sonra([73, 74, 75, 71, 69, 72, 76, 73]))

2. Heap: en büyük k ve ağırlıklı en kısa yol

heapq en küçük elemanı her zaman h[0]'da tutan bir min-heap'tir; ekleme ve çıkarma O(log n). "En büyük k" için boyutu k olan bir min-heap tut: yeni eleman tepedekinden büyükse değiştir. Böylece n elemanı O(n log k)'da tararsın; heapq.nlargest bunu hazır yapar. Max-heap gerekiyorsa değerleri eksiyle çarparak koy. Dijkstra algoritması da heap'e dayanır: her adımda en yakın düğümü çıkarırsın.

import heapq

siparisler = [("S1", 420), ("S2", 90), ("S3", 1250), ("S4", 610), ("S5", 300)]
print(heapq.nlargest(2, siparisler, key=lambda s: s[1]))

def dijkstra(graf, bas):
    mesafe = {bas: 0}
    h = [(0, bas)]
    while h:
        d, u = heapq.heappop(h)
        if d > mesafe.get(u, float("inf")):
            continue                     # eski, geçersiz kayıt
        for v, w in graf.get(u, []):
            yeni = d + w
            if yeni < mesafe.get(v, float("inf")):
                mesafe[v] = yeni
                heapq.heappush(h, (yeni, v))
    return mesafe

yollar = {"Depo": [("Kadıköy", 12), ("Beşiktaş", 7)],
          "Beşiktaş": [("Kadıköy", 3), ("Şişli", 4)],
          "Kadıköy": [("Ataşehir", 6)], "Şişli": [("Ataşehir", 15)]}
print(dijkstra(yollar, "Depo"))

3. Önek toplamı

onek[i] ilk i elemanın toplamıysa, i..j aralığının toplamı onek[j+1] - onek[i] olur. "Toplamı k olan kaç alt dizi var?" sorusunda her konumda "şimdiye kadarki toplam - k" değerinin daha önce kaç kez görüldüğünü sözlükte sayarsın. Negatif sayılar olduğunda kayan pencere çalışmaz, önek toplamı çalışır; bu ayrımı söylemek artı puandır.

4. Dinamik programlama

İki işaret ara: optimal alt yapı (büyük problemin cevabı küçüklerinkinden kurulur) ve örtüşen alt problemler (aynı küçük problem tekrar tekrar çözülür). İki yazım şekli vardır: yukarıdan aşağı (özyineleme + functools.cache) ve aşağıdan yukarı (tablo). Mülakatta önce özyinelemeli tanımı söyle, sonra tabloya çevir.

from functools import cache

def para_ustu(bozuklar, tutar):
    """En az kaç bozuk para? Mümkün değilse -1."""
    SONSUZ = float("inf")
    dp = [0] + [SONSUZ] * tutar          # dp[t]: t tutarı için en az para
    for t in range(1, tutar + 1):
        for b in bozuklar:
            if b <= t and dp[t - b] + 1 < dp[t]:
                dp[t] = dp[t - b] + 1
    return dp[tutar] if dp[tutar] != SONSUZ else -1

print(para_ustu([1, 5, 10, 25], 63), para_ustu([5, 10], 3))

@cache
def yol_sayisi(satir, sutun):
    """Izgarada sol üstten sağ alta yalnız sağ/aşağı giderek kaç yol?"""
    if satir == 1 or sutun == 1:
        return 1
    return yol_sayisi(satir - 1, sutun) + yol_sayisi(satir, sutun - 1)

print(yol_sayisi(3, 7), yol_sayisi.cache_info().hits)

5. Geri izleme ve aralıklar

Geri izleme, seçim yap, özyinele, seçimi geri al döngüsüdür. "Toplamı hedef olan tüm kombinasyonlar" ya da "tüm alt kümeler" bu kalıptır; dalı erken kesmek (pruning, ör. sıralı adaylarda toplam aşınca break) süreyi ciddi biçimde düşürür. Aralık sorularında ise neredeyse her zaman ilk adım başlangıca göre sıralamaktır.

def birlestir(araliklar):
    sonuc = []
    for bas, bit in sorted(araliklar):
        if sonuc and bas <= sonuc[-1][1]:
            sonuc[-1][1] = max(sonuc[-1][1], bit)
        else:
            sonuc.append([bas, bit])
    return sonuc

print(birlestir([(9, 11), (1, 3), (2, 6), (8, 10), (15, 18)]))

def alt_kumeler(ogeler):
    sonuc, secim = [], []
    def gez(i):
        if i == len(ogeler):
            sonuc.append(secim.copy())   # kopyala: secim değişmeye devam edecek
            return
        secim.append(ogeler[i]); gez(i + 1)   # al
        secim.pop();             gez(i + 1)   # alma (geri al)
    gez(0)
    return sonuc

print(alt_kumeler(["çay", "simit", "peynir"]))

Bu ders her rol için ortak çekirdeği veriyor: Python kavramları, algoritma kalıpları, canlı kodlama ve davranışsal sorular. Ama bir veri analisti ile bir backend geliştiricinin mülakatı aynı değildir. Bu bölüm iki şey ekliyor: öğrenme yoluna göre "hangi bölüm sana ne kadar lazım" haritası ve kendi kendine uygulayabileceğin 45 dakikalık bir deneme mülakatı senaryosu.

Öğrenme yollarına göre harita

Haritayı şöyle kullan: kendi satırındaki ilk sütunu bu derste pekiştir, ikinci sütundaki dersleri sırayla bitir, üçüncü sütunu deneme mülakatlarında ağırlık olarak kullan. Python Arena'da rolüne uygun alan süzgeciyle günde 1-2 soru çözmek, kalıpları otomatikleştirmenin en verimli yoludur.

45 dakikalık deneme mülakatı

Gerçek teknik mülakatların çoğu 45-60 dakikadır ve benzer bir akışı izler. Bir arkadaşınla rol değiştirerek ya da kendi kendine süre tutarak uygula; ekranını kaydet ve sonra izle. Senaryo Anadolu Market'in backend/veri pozisyonuna göre yazıldı.

Canlı kodlama problemi (25 dakika)

Görev: "Sipariş akışında her sipariş (musteri_id, zaman_sn) olarak geliyor. Son 60 saniyede 3'ten fazla sipariş veren müşterileri, sınırı ilk aştıkları an itibarıyla raporla." Takip sorusu: "Akış sıralı gelmiyorsa ne değişir? Bellek sınırlıysa?"

from collections import defaultdict, deque

def supheliler(siparisler, pencere=60, sinir=3):
    son = defaultdict(deque)          # müşteri -> penceredeki zamanlar
    bulunan = {}
    for musteri, t in siparisler:     # zaman sırasıyla geldiğini varsayıyoruz (netleştir!)
        q = son[musteri]
        q.append(t)
        while q[0] <= t - pencere:    # pencereden çıkanları at
            q.popleft()
        if len(q) > sinir and musteri not in bulunan:
            bulunan[musteri] = t
    return bulunan

akis = [(7, 0), (7, 10), (9, 12), (7, 30), (7, 55), (9, 70), (7, 61), (7, 62)]
print(supheliler(akis))

Değerlendirme ölçütleri: Soruyu netleştirdin mi (pencere dahil mi, sıralı mı)? Kaba çözümü söyleyip (her siparişte tüm geçmişi taramak, O(n²)) iyileştirdin mi? Karmaşıklığı söyledin mi (her zaman en fazla bir kez eklenip çıkarılır: O(n) zaman, O(müşteri × pencere) bellek)? Kenar durumları denedin mi (aynı saniyede sipariş, tam 60 saniye sınırı)?

Kendini puanla