code stringlengths 35 1.46k | explanation stringlengths 152 368 |
|---|---|
def mergeTwoLists(list1, list2):
dummy = ListNode()
curr = dummy
while list1 and list2:
if list1.val < list2.val:
curr.next = list1
list1 = list1.next
else:
curr.next = list2
list2 = list2.next
curr = curr.next
curr.next = list1 or ... | İki sıralı bağlı listeyi, elemanları küçükten büyüğe olacak şekilde tek bir liste haline getirir. Listenin başındaki kukla düğümden kurtulup birleşenleri döndüren, sanki iki ayrı kavgacı grubu barış masasında yan yana oturtan huzur bozucu bir fonksiyon. |
def maxSubArray(nums):
max_sum = current_sum = nums[0]
for num in nums[1:]:
current_sum = max(num, current_sum + num)
max_sum = max(max_sum, current_sum)
return max_sum | Kadane algoritmasını kullanarak dizideki ardışık elemanların toplamının ulaşılabilecek en yüksek değerini bulur. Listeyi bir tur atıp hangi parçanın toplamda daha çok kazandırdığını çözen, tam bir ticaret kafasıyla çalışan fonksiyon. |
def reverseString(s):
left, right = 0, len(s) - 1
while left < right:
s[left], s[right] = s[right], s[left]
left += 1
right -= 1 | İki uçtan başlayıp elemanları birbiriyle takas ederek stringi tersine çeviren klasik bir algoritmadır. Sanki kalabalık bir otobüste orta koltukta oturanlar yer değiştirene kadar birbirinin üzerinden atlayan yolculara benziyor. |
def isAnagram(s, t):
if len(s) != len(t): return False
counts = {}
for char in s:
counts[char] = counts.get(char, 0) + 1
for char in t:
if char not in counts or counts[char] == 0:
return False
counts[char] -= 1
return True | Verilen iki metnin aynı harflerden oluşup oluşmadığını, yani birbirinin anagramı olup olmadıklarını kontrol eder. Bir kelimeyi parçalayıp harf sayımını tutan bu fonksiyon, sanki harf stokçuluğu yapan bir bakkal gibi çalışıyor. |
def containsDuplicate(nums):
return len(set(nums)) != len(nums) | Listeyi bir sete çevirip boyutlarını karşılaştırarak içinde tekrar eden eleman olup olmadığını kontrol eden fonksiyon. Liste elemanları birbirini kopyalayıp çoğalmış mı diye anlamaya çalışan, işi gücü yokmuş gibi sürekli dedektiflik yapan bir yapı. |
def maxProfit(prices):
min_price = float('inf')
max_profit = 0
for price in prices:
if price < min_price:
min_price = price
elif price - min_price > max_profit:
max_profit = price - min_price
return max_profit | Hisse fiyatlarını tek geçişte tarayarak en düşükten alıp en yüksekten satma stratejisini hesaplayan bir fonksiyon. Borsa düşüşünde ağlayıp yükselişinde sevinen yatırımcı gibi, karı maksimize edene kadar sabırla bekliyor. |
def singleNumber(nums):
result = 0
for num in nums:
result ^= num
return result | XOR operatörünü kullanarak listede bir kez tekrarlanan sayıyı bulan, gereksiz diğer eşleri de birbirine kırdırıp yok eden fonksiyon. Kendisinden başka eşi olmayan o yalnız sayıyı bulana kadar tüm listeyi birbirine vurduruyor, tam bir kaos ortamı. |
def search(nums, target):
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1 | Sıralı bir listede aradığınız hedefi Binary Search algoritmasıyla ortadan ikiye bölerek bulan fonksiyon. Sanki rehberde isim arıyor gibi tüm sayfaları tek tek çevirmek yerine, ortadan dalıp işini kısa sürede bitiren o hızlı arkadaşımız. |
def climbStairs(n):
if n <= 2: return n
a, b = 1, 2
for _ in range(3, n + 1):
a, b = b, a + b
return b | Basamak sayısını parametre alarak kaç farklı şekilde tırmanılabileceğini bulan ve aslında Fibonacci dizisini kullanan bir algoritma. Adım sayısını hesaplamak için sürekli eski değerleri toplayıp ilerliyor, sanki merdiven değil de kendi maaş hesabını yapıyor. |
def invertTree(root):
if not root:
return None
root.left, root.right = invertTree(root.right), invertTree(root.left)
return root | Binary tree yapısındaki her düğümün sağ ve sol çocuklarını birbiriyle yer değiştirerek ağacı aynalayan, Google'ın mülakatlarda milleti terlettiği meşhur algoritmadır. Sanki ağaca ters düz takla attırıp, sağ elini sol cebine, sol elini sağ cebine sokan aşırı özgüvenli bir fonksiyon. |
def maxDepth(root):
if not root:
return 0
return 1 + max(maxDepth(root.left), maxDepth(root.right)) | Ağaç yapısındaki verinin en derin noktasına kadar inerek toplam derinliği bulan recursive bir işlemdir. Dalların arasından kaybolmadan en dibe ulaşıp oradan yukarı kaçan bir köstebek gibi çalışıyor, tam bir hayatta kalma mücadelesi. |
def moveZeroes(nums):
pos = 0
for i in range(len(nums)):
if nums[i] != 0:
nums[pos], nums[i] = nums[i], nums[pos]
pos += 1 | Listedeki tüm sıfır olmayan sayıları başa toplayıp sıfırları sona paslayan, Two Pointers tekniğini kullanan bir fonksiyon. Sayıları kaydırırken sanki halay başını çekip sıfırları düğünün en arkasına, halaydan kovulan dayıların yanına gönderiyor. |
def missingNumber(nums):
n = len(nums)
expected_sum = n * (n + 1) // 2
return expected_sum - sum(nums) | 0'dan n'e kadar olan sayıların toplam formülünden mevcut listenin toplamını çıkararak eksik olan elemanı bulur. Sanki tüm sınıf yoklamaya gelmiş gibi yapıp bir kişinin eksik olduğunu matematiksel olarak çakozlayan kurnaz bir fonksiyon. |
def reverse(x):
sign = -1 if x < 0 else 1
x = abs(x)
rev = int(str(x)[::-1]) * sign
if rev < -2**31 or rev > 2**31 - 1:
return 0
return rev | Verilen tam sayının basamaklarını tersine çevirirken 32-bit sınırlarını aşarsa diye güvenlik önlemi alan bir fonksiyon. Rakamları yer değiştirip "ben aslında yoğum" diyerek taşma durumunda sıfıra dönen, tam bir köşe dönme ustası. |
def romanToInt(s):
roman = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
total = 0
for i in range(len(s) - 1):
if roman[s[i]] < roman[s[i+1]]:
total -= roman[s[i]]
else:
total += roman[s[i]]
return total + roman[s[-1]] | Roma rakamlarını standart sayı sistemine dönüştüren bu fonksiyon, karakterlerin değerlerini tek tek toplar veya bir sonraki değer daha büyükse çıkarır. Antik Roma'da vergi memurlarının matematiksel kafa karışıklığını gidermek için kullandığı, resmen "kardeşim sen ne yapıyorsun" dedirten o karmaşık hesaplama mantığı işt... |
def longestCommonPrefix(strs):
if not strs: return ""
shortest = min(strs, key=len)
for i, char in enumerate(shortest):
for other in strs:
if other[i] != char:
return shortest[:i]
return shortest | String listesindeki tüm kelimelerin başında ortak olan en uzun karakter dizisini tespit eder. Liste boşsa veya ilk harften itibaren uyumsuzluk başlarsa hemen havlu atıp elindekiyle yetinen oldukça mütevazı bir algoritma. |
def removeDuplicates(nums):
if not nums: return 0
i = 0
for j in range(1, len(nums)):
if nums[j] != nums[i]:
i += 1
nums[i] = nums[j]
return i + 1 | Sıralı bir listedeki tekrarlanan sayıları, listeyi yerinde değiştirerek silen klasik bir "iki işaretçi" algoritmasıdır. Sanki partiye davetsiz gelen ikizleri tek tek kapı dışarı edip, içeride sadece orijinal karakterleri bırakan bir fedai gibi çalışıyor. |
def lengthOfLastWord(s):
return len(s.strip().split(" ")[-1]) | Cümleyi baştaki ve sondaki boşluklardan temizleyip kelimelere ayırarak sonuncusunun uzunluğunu döndürür. Sanki birisi cümleyi okuyup sadece son kelimeyi hecelemekten acizmiş gibi, işin tüm yükünü bilgisayara yıkan bir fonksiyon. |
def plusOne(digits):
for i in range(len(digits)-1, -1, -1):
if digits[i] < 9:
digits[i] += 1
return digits
digits[i] = 0
return [1] + digits | Listedeki basamakları sondan başlayarak bir artırır, eğer sayı 9 ise onu 0 yapıp eldeki biri bir sonraki basamağa devreder. Sanki ilkokulda elde var bir hesabı yapıyormuşuz gibi, rakamlar 9'dan büyükse bizi uğraştırıp duran bir fonksiyon. |
def isPalindrome(s):
cleaned = [c.lower() for c in s if c.isalnum()]
return cleaned == cleaned[::-1] | Metin içindeki harf ve rakam dışındaki çöpleri atıp küçük harfe çevirerek, ifadenin tersten okununca da aynı olup olmadığını denetler. Cümlenin düzüyle tersi birbirine selam duruyorsa palindromdur, yoksa "hadi oradan" der geçer. |
def strStr(haystack, needle):
if not needle: return 0
return haystack.find(needle) | `haystack` içerisinde aranan `needle` metninin başlangıç indeksini bulan, bulamazsa da -1 dönerek "buralarda o isimde biri yok" diyen fonksiyon. Kendi kendine kütüphane fonksiyonu kullanıp işin kolayına kaçan, biraz tembel ama oldukça pratik bir arkadaşımız kendisi. |
def searchInsert(nums, target):
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return left | Sıralı bir listede binary search mantığıyla hedef sayıyı arar, bulamazsa da olması gereken indeksi döndürür. Sanki bir sınıfa girip "Ben burada değilim ama numaram kaç olmalıydı?" diye soran öğrenci gibi çalışan, iş bitirici bir fonksiyon. |
def mySqrt(x):
left, right = 0, x
while left <= right:
mid = (left + right) // 2
if mid * mid <= x < (mid + 1) * (mid + 1):
return mid
elif x < mid * mid:
right = mid - 1
else:
left = mid + 1 | Binary search algoritması kullanarak bir sayının karekökünü tam sayı olacak şekilde bulur. Kendi başına karekök almaktan aciz olan işlemciyi, aralık daraltarak çözüme götüren yorucu bir fonksiyon. |
def removeElements(head, val):
dummy = ListNode(next=head)
prev, curr = dummy, head
while curr:
if curr.val == val:
prev.next = curr.next
else:
prev = curr
curr = curr.next
return dummy.next | Bağlı listedeki istenmeyen değerleri silmek için işaretçileri birbirine bağlayıp elemanları aradan çıkaran bir temizlik fonksiyonu. Sanki kalabalık bir partiden sevilmeyen misafirleri kibarca kapı dışarı ediyormuşuz gibi çalışıyor. |
def reverseList(head):
prev = None
curr = head
while curr:
next_node = curr.next
curr.next = prev
prev = curr
curr = next_node
return prev | Bağlı listedeki düğümlerin birbirine bağlanan işaretçilerini tersine çevirerek listeyi tamamen baştan sona döndüren bir algoritmadır. Birbirine küsmüş düğümleri sırayla çevirip yeni düzene sokan, adeta listede ters yöne giden tek yönlü yolcu gibi çalışan bir fonksiyon. |
def hasCycle(head):
slow, fast = head, head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False | Floyd'un kaplumbağa ve tavşan algoritmasını kullanarak bağlı listede döngü olup olmadığını kontrol eder. Hızlı olanın yavaş olanı yakaladığı bu kovalamaca, eğer liste sonsuz bir döngüye girdiyse True sonucunu döndürür. |
def getIntersectionNode(headA, headB):
if not headA or not headB: return None
currA, currB = headA, headB
while currA != currB:
currA = currA.next if currA else headB
currB = currB.next if currB else headA
return currA | İki bağlı listenin kesiştiği düğümü bulan bu fonksiyon, birbirini bekleyen iki inatçı turist gibi döngüleri döndürerek ortak noktayı buluyor. Pointerlar birbirlerinin listesine geçiş yaparak, sanki yanlış durakta inmiş otobüs şoförleri gibi sonunda aynı kesişim düğümünde buluşuyorlar. |
def middleNode(head):
slow, fast = head, head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
return slow | Bağlı listeyi bir kaplumbağa ve tavşan gibi önce yavaş, sonra ikişer adım hızlı ilerleterek tam orta noktayı bulan fonksiyon. Tavşan bitişe vardığında, kaplumbağa listenin ortasına çoktan park etmiş oluyor. |
def isPalindrome(head):
vals = []
curr = head
while curr:
vals.append(curr.val)
curr = curr.next
return vals == vals[::-1] | Bağlı listenin tüm elemanlarını bir diziye kopyalayıp dizinin düz ve ters halini karşılaştırarak palindrom olup olmadığını kontrol eder. Hafızayı biraz yoruyor ama liste elemanlarını tek tek elle çevirmekle uğraşmak istemeyen tembel geliştiriciler için birebir. |
def firstBadVersion(n):
left, right = 1, n
while left < right:
mid = (left + right) // 2
if isBadVersion(mid):
right = mid
else:
left = mid + 1
return left | Binary Search algoritmasını kullanarak hatalı versiyonu bulur. Hangi versiyonun arızalı olduğunu anlamak için yarım yamalak tahminlerle sürekli sistemi kurcalayan ve sonunda suçluyu bulan tipik bir dedektif fonksiyonu. |
def isPowerOfTwo(n):
return n > 0 and (n & (n - 1)) == 0 | Bitwise operatörleri kullanarak sayının 2'nin bir kuvveti olup olmadığını kontrol eden fonksiyon. İkili sistemdeki tek bir biti yakalayıp diğerlerini sıfırlayarak "ben 2'nin kuvvetiyim" diye bağıran, biraz şekilci bir arkadaşımız. |
def isPowerOfThree(n):
if n <= 0: return False
while n % 3 == 0:
n //= 3
return n == 1 | Verilen sayının 3'ün tam kuvveti olup olmadığını, sürekli 3'e bölerek kontrol eden matematiksel bir döngü kurar. Sayıyı üçer üçer parçalayıp elde avuçta bir kalıp kalmadığına bakan, biraz cimri bir fonksiyon. |
def firstUniqChar(s):
counts = {}
for char in s:
counts[char] = counts.get(char, 0) + 1
for i, char in enumerate(s):
if counts[char] == 1:
return i
return -1 | Metin içindeki her karakterin kaç kez geçtiğini sayıp, frekansı sadece 1 olan ilk karakterin indeksini döndürür. Yalnız kalmış karakteri ararken resmen yalnızlar rıhtımında serserilik yapan, çok dertli bir fonksiyon. |
def fizzBuzz(n):
res = []
for i in range(1, n + 1):
if i % 15 == 0: res.append("FizzBuzz")
elif i % 3 == 0: res.append("Fizz")
elif i % 5 == 0: res.append("Buzz")
else: res.append(str(i))
return res | 1'den n'e kadar olan sayıları döngüye sokup 3'ün katlarına Fizz, 5'inkilere Buzz, 15'inkilere ise ikisini birden yapıştırıp listeye ekleyen meşhur mülakat sorusu. Yazılımcıların çocukluk travması olan bu FizzBuzz, bilgisayarı biraz yorup ortaya karışık bir liste çıkarmaktan başka bir işe yaramıyor. |
def findDisappearedNumbers(nums):
for num in nums:
index = abs(num) - 1
if nums[index] > 0:
nums[index] *= -1
return [i + 1 for i in range(len(nums)) if nums[i] > 0] | Dizideki sayıların varlığını indeksleri negatif yaparak işaretleyip, sonra pozitif kalan indeksleri bulan bir yöntemdir. Sanki liste içinde saklambaç oynayan çocukları bulmaya çalışan, sürekli başkalarının üzerine basıp geçen yaramaz bir çocuk gibi davranıyor. |
def majorityElement(nums):
count, candidate = 0, None
for num in nums:
if count == 0:
candidate = num
count += (1 if num == candidate else -1)
return candidate | Boyer-Moore Voting algoritması kullanılarak dizideki elemanların yarısından fazlasını oluşturan elemanı bulur. Sanki bir sınıfta en çok konuşanı oylama usulüyle tespit eden ama oyları da kafasına göre eşleştirip silen tuhaf bir sistem gibi çalışıyor. |
def convertToTitle(columnNumber):
res = ""
while columnNumber > 0:
columnNumber -= 1
res = chr(columnNumber % 26 + 65) + res
columnNumber //= 26
return res | Excel sütun başlıklarını sayıdan harf dizisine çeviren bu fonksiyon, her adımda 26'lık sistemde mod alarak karakterleri oluşturur. İnsan Excel'de sütun ismini merak edince Excel'in kendi kendine konuştuğu garip dillerden birini çözüyor resmen. |
def isSameTree(p, q):
if not p and not q: return True
if not p or not q or p.val != q.val: return False
return isSameTree(p.left, q.left) and isSameTree(p.right, q.right) | İki ağaç yapısının hem düğüm değerlerini hem de çocuklarını özyinelemeli olarak karşılaştırıp tıpatıp aynı olup olmadıklarını kontrol eder. Kardeşini bile birbirinden ayırmayan, sadece ikizleri seven kılı kırk yaran bir fonksiyon kendisi. |
def isSymmetric(root):
def isMirror(t1, t2):
if not t1 and not t2: return True
if not t1 or not t2: return False
return (t1.val == t2.val) and isMirror(t1.right, t2.left) and isMirror(t1.left, t2.right)
return isMirror(root, root) if root else True | İki ağaç dalının birbirinin kopyası değil, tam tersi yönde ayna görüntüsü olup olmadığını kontrol eden bir yapıdır. Ağacın sol ve sağ kollarını sanki kendine bakıyormuş gibi karşılaştırır, eğer birbirlerini tamamlarlarsa simetriktir der geçer. |
def hasPathSum(root, targetSum):
if not root: return False
if not root.left and not root.right and root.val == targetSum:
return True
return hasPathSum(root.left, targetSum - root.val) or hasPathSum(root.right, targetSum - root.val) | Ağaç yapısındaki düğümlerin değerlerini kökten yaprağa kadar toplayıp hedef sayıya ulaşıp ulaşmadığımızı kontrol eden özyinelemeli bir fonksiyon. Kendi yolunda ilerleyip toplama hatası yapınca hemen geri dönen, biraz kararsız bir gezgin gibi çalışıyor. |
def twoSum(numbers, target):
left, right = 0, len(numbers) - 1
while left < right:
total = numbers[left] + numbers[right]
if total == target:
return [left + 1, right + 1]
elif total < target:
left += 1
else:
right -= 1
return [] | Sorted bir listede toplamları hedefe eşit olan iki sayının indisini bulan meşhur Two Pointers algoritmasıdır. Sağdan ve soldan kırpılan bu fonksiyon, aradığınız toplamı bulamazsa eli boş dönerek sizi üzebilir. |
def isSubsequence(s, t):
i, j = 0, 0
while i < len(s) and j < len(t):
if s[i] == t[j]:
i += 1
j += 1
return i == len(s) | Bir dizinin diğerinin içinde sırasını bozmadan gizlenip gizlenmediğini kontrol eden bu fonksiyon, dedektif gibi çalışır. Eğer s dizisindeki tüm karakterleri t içinde sırayla bulursan True döner, aksi halde "aradım ama bulamadım" diyerek seni başından savar. |
def lengthOfLongestSubstring(s):
seen = {}
left = max_len = 0
for right, char in enumerate(s):
if char in seen and seen[char] >= left:
left = seen[char] + 1
seen[char] = right
max_len = max(max_len, right - left + 1)
return max_len | Bir string içinde tekrarlanan karakterlere rastlamadan oluşturulabilecek en uzun alt dizinin uzunluğunu bulan kaydırmalı pencere (sliding window) algoritmasıdır. Sağdan karakter ekleyip soldan daralan penceresiyle, sanki metroda boş koltuk kovalayan yolcular gibi sürekli yer değiştiren garip bir fonksiyon. |
def groupAnagrams(strs):
groups = {}
for s in strs:
key = tuple(sorted(s))
groups.setdefault(key, []).append(s)
return list(groups.values()) | Kelime içindeki harfleri alfabetik sıraya dizip bunları anahtar yaparak aynı harfleri içeren kelimeleri gruplar. Kendi içinde aynı harf çorbasından çıkanları aynı kaba koyan, tam bir mutfak robotu gibi çalışan fonksiyon. |
from collections import Counter
def topKFrequent(nums, k):
count = Counter(nums)
return [item[0] for item in count.most_common(k)] | Gelen listedeki sayıların frekansını hesaplayıp en çok tekrar eden ilk k adet elemanı döndüren fonksiyondur. Sayıları popülarite yarışına sokup, sadece en fazla seveni olan ilk k tanesini listeye toplayan tam bir torpilci sistemdir. |
def productExceptSelf(nums):
res = [1] * len(nums)
prefix = 1
for i in range(len(nums)):
res[i] = prefix
prefix *= nums[i]
postfix = 1
for i in range(len(nums) - 1, -1, -1):
res[i] *= postfix
postfix *= nums[i]
return res | Listenin her bir elemanını, kendisi hariç diğer tüm elemanların çarpımıyla güncelleyen, bölme operatörü kullanmadan hesaplama yapan bir algoritma. Sanki herkesin birbirini çarptığı bir mahalle kavgasına dahil olup, sadece kendini dışarıda bırakan çapkın bir fonksiyon. |
def findMin(nums):
left, right = 0, len(nums) - 1
while left < right:
mid = (left + right) // 2
if nums[mid] > nums[right]:
left = mid + 1
else:
right = mid
return nums[left] | Binary search kullanarak sıralı ve kaydırılmış bir dizideki en küçük elemanı bulan fonksiyon. Sürekli ortayı ikiye bölüp "sen mi küçüksün yoksa ben mi daha büyüğüm" diye kavga ettirerek sonunda en gariban sayıyı bulup çıkartıyor. |
def maxDepth(root):
if not root: return 0
if not root.children: return 1
return 1 + max(maxDepth(child) for child in root.children) | Ağaç yapısındaki düğümlerin derinliğini özyinelemeli olarak hesaplayıp en uzun yolu bulan fonksiyon. Sanki dipteki düğüme "daha ne kadar aşağı gideceğiz kardeşim?" diye sorup cevabı 1 arttırarak yukarı dönüyor. |
def searchBST(root, val):
while root:
if root.val == val: return root
root = root.left if val < root.val else root.right
return None | Binary search tree yapısında aranan değeri bulana kadar sola veya sağa dallanan bir fonksiyon. Aradığını bulamayınca eli boş dönen, biraz seçici ve içine kapanık bir arkadaş kendisi. |
def insertIntoBST(root, val):
if not root: return TreeNode(val)
if val < root.val:
root.left = insertIntoBST(root.left, val)
else:
root.right = insertIntoBST(root.right, val)
return root | İkili arama ağacına (BST) yeni değeri uygun yere yerleştirene kadar özyinelemeli olarak ilerleyen bir fonksiyon. Kendi kendine, "ben nereye aitim" diye soran, aradığı boşluğu bulduğunda ise oraya hemen yerleşen bir fonksiyon işte. |
def lowestCommonAncestor(root, p, q):
while root:
if p.val < root.val and q.val < root.val:
root = root.left
elif p.val > root.val and q.val > root.val:
root = root.right
else:
return root | Binary Search Tree üzerinde p ve q düğümlerinin ortak atasına ulaşana kadar kök dizininde aşağı inen bir algoritmadır. Sanki sülale araştırması yapıp "ha tamam, burada buluştuk" diyen, soy ağacını kafaya takmış lavuk gibi çalışır. |
def kthSmallest(root, k):
stack = []
while True:
while root:
stack.append(root)
root = root.left
root = stack.pop()
k -= 1
if k == 0: return root.val
root = root.right | Binary Search Tree yapısındaki verileri küçükten büyüğe doğru sıralayan In-order traversal mantığını kullanarak k. sıradaki elemanı bulur. Sanki ağacın dallarını tek tek sayıp aradığınız kişiyi bulan, işsiz güçsüz bir dedektif gibi davranıyor. |
def isValidBST(root, min_val=float('-inf'), max_val=float('inf')):
if not root: return True
if not (min_val < root.val < max_val): return False
return isValidBST(root.left, min_val, root.val) and isValidBST(root.right, root.val, max_val) | İkili arama ağacındaki her düğümün kendi sınırları içinde olup olmadığını kontrol ederek ağacın mantıksal düzenini denetler. Evdeki çocukların sürekli kuralları çiğnemeye çalışması gibi, bu fonksiyon da "senin değerin aslında buraya ait değil" diyerek ağacı hizaya sokuyor. |
def levelOrder(root):
if not root: return []
res, queue = [], [root]
while queue:
level = []
for _ in range(len(queue)):
node = queue.pop(0)
level.append(node.val)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
... | Ağaç yapısındaki verileri en üst seviyeden başlayarak katman katman gezen Breadth-First Search mantığıyla çalışır. Yazılım dünyasının "hadi herkes sıraya, düzenli olalım" diye bağıran, tüm düğümleri seviye seviye listeleyen bir disiplin subayıdır. |
def rightSideView(root):
if not root: return []
res, queue = [], [root]
while queue:
res.append(queue[-1].val)
for _ in range(len(queue)):
node = queue.pop(0)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
return res | Ağaç yapısındaki her seviyenin en sağındaki elemanı seçip listeye ekleyen bir BFS algoritmasıdır. Sanki binaya dışarıdan bakıyormuşuz gibi sadece en sağdaki balkonları gören, sol tarafla pek ilgilenmeyen biraz vizyonsuz bir fonksiyon. |
def numIslands(grid):
if not grid: return 0
def dfs(r, c):
if r < 0 or c < 0 or r >= len(grid) or c >= len(grid[0]) or grid[r][c] == '0': return
grid[r][c] = '0'
dfs(r+1, c); dfs(r-1, c); dfs(r, c+1); dfs(r, c-1)
islands = 0
for i in range(len(grid)):
for j in range(len(g... | Izgaradaki '1' değerlerini kara parçası kabul edip, DFS algoritmasıyla komşu hücreleri silerek ada sayısını bulan bir fonksiyon. Haritayı gezmeye çıkan kaşif gibi, bulduğu adayı bir daha saymamak için anında haritadan siliyor; iş bitince de geriye sadece kaç ada kaldığı kalıyor. |
def maxAreaOfIsland(grid):
def dfs(r, c):
if r < 0 or c < 0 or r >= len(grid) or c >= len(grid[0]) or grid[r][c] == 0: return 0
grid[r][c] = 0
return 1 + dfs(r+1, c) + dfs(r-1, c) + dfs(r, c+1) + dfs(r, c-1)
return max(dfs(r, c) for r in range(len(grid)) for c in range(len(grid[0]))) | Grid üzerindeki 1 değerlerini DFS algoritması ile tarayıp birbirine bağlı olanların sayısını bulan ve en büyük ada parçasını hesaplayan bir fonksiyondur. Harita üzerinde gezinen bir turist gibi her adayı teker teker keşfettikten sonra, üzerinde en çok güneşlendiği devasa adayı bulup bize raporluyor. |
def floodFill(image, sr, sc, color):
start_color = image[sr][sc]
if start_color == color: return image
def dfs(r, c):
if 0 <= r < len(image) and 0 <= c < len(image[0]) and image[r][c] == start_color:
image[r][c] = color
dfs(r+1, c); dfs(r-1, c); dfs(r, c+1); dfs(r, c-1)
d... | Depth-first search yani derinlemesine arama kullanarak, komşu pikselleri hedef renkle boyayan bir fonksiyon. Eskiden boyama kitabında taşırınca gelen o pişmanlık hissini, bilgisayara kodla yaşatan tam bir baş belası. |
def cloneGraph(node):
if not node: return None
old_to_new = {}
def dfs(curr):
if curr in old_to_new: return old_to_new[curr]
copy = Node(curr.val)
old_to_new[curr] = copy
for neighbor in curr.neighbors:
copy.neighbors.append(dfs(neighbor))
return copy
... | Graflardaki düğümleri ve bağlantılarını kopyalayan bu fonksiyon, DFS algoritmasını kullanarak birbirine kenetlenmiş bir yapının tıpatıp aynısını oluşturur. Kendini kopyalamaya çalışan bu narsist yapı, her düğümün değerini ve komşuluk ilişkilerini hatasız şekilde hafızaya alıp yeniden inşa ediyor. |
class Trie:
def __init__(self):
self.root = {}
def insert(self, word):
node = self.root
for char in word:
if char not in node:
node[char] = {}
node = node[char]
node['*'] = True
def search(self, word):
node = self.root
f... | Kelimeleri harf harf ağaç yapısına dizerek saklayan bu Trie sınıfı, veri aramayı hızlandıran bir algoritmadır. Sanki bütün kelimeleri bir kütüphaneye değil de, her harfi bir dal kabul eden devasa bir şecere ağacına yerleştiriyoruz, ararken de ağaçta maymun gibi daldan dala atlıyoruz. |
def minCostClimbingStairs(cost):
cost.append(0)
for i in range(len(cost) - 3, -1, -1):
cost[i] += min(cost[i+1], cost[i+2])
return min(cost[0], cost[1]) | Dinamik programlama kullanarak basamakları en az maliyetle tırmanmanızı sağlayan bir mantık bu. Sanki yorulmamak için sürekli en ucuz arkadaşını seçip sırtına binen, cimri bir öğrenci gibi davranıyor. |
def rob(nums):
rob1, rob2 = 0, 0
for n in nums:
temp = max(n + rob1, rob2)
rob1 = rob2
rob2 = temp
return rob2 | Dynamic Programming kullanarak bitişik olmayan evlerden en yüksek değeri çalmayı sağlayan House Robber algoritmasıdır. Hırsızın vicdanı sızlamasın diye yan yana iki evi soymayan, oldukça seçici ve mesafeli bir fonksiyon. |
def rob2(nums):
if len(nums) == 1: return nums[0]
def helper(arr):
rob1, rob2 = 0, 0
for n in arr:
temp = max(n + rob1, rob2)
rob1 = rob2
rob2 = temp
return rob2
return max(helper(nums[:-1]), helper(nums[1:])) | Dairesel bir mahalledeki evleri soyarken yan yana iki evi soyamayacağınız için, komşu evleri dışarıda bırakıp maksimum ganimeti hesaplayan dinamik programlama fonksiyonu. Evleri soymak için bir oraya bir buraya koşturup duruyor ama yakalanmamak için epey bir matematiksel takla atıyor. |
def coinChange(coins, amount):
dp = [amount + 1] * (amount + 1)
dp[0] = 0
for a in range(1, amount + 1):
for c in coins:
if a - c >= 0:
dp[a] = min(dp[a], 1 + dp[a - c])
return dp[amount] if dp[amount] != amount + 1 else -1 | Dinamik programlama kullanarak, belirli madeni para çeşitleriyle hedef tutara en az kaç adet parayla ulaşılacağını hesaplar. Bir nevi bakkalda para üstü verirken matematik olimpiyatlarına katılmış gibi düşünen aşırı detaycı bir fonksiyon. |
def lengthOfLIS(nums):
LIS = [1] * len(nums)
for i in range(len(nums) - 1, -1, -1):
for j in range(i + 1, len(nums)):
if nums[i] < nums[j]:
LIS[i] = max(LIS[i], 1 + LIS[j])
return max(LIS) | Dinamik programlama kullanarak bir dizideki en uzun artan alt dizinin uzunluğunu bulan algoritmadır. Kendi kendine "ben ne kadar uzayabilirim" diye dertlenen, her elemanı tek tek sorgulayan bu arkadaşa klasik LIS problemi diyoruz. |
def longestCommonSubsequence(text1, text2):
dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
for i in range(len(text1) - 1, -1, -1):
for j in range(len(text2) - 1, -1, -1):
if text1[i] == text2[j]:
dp[i][j] = 1 + dp[i+1][j+1]
else:
dp[i... | İki metin arasındaki en uzun ortak alt dizinin uzunluğunu dinamik programlama ile hesaplayan fonksiyon. İki kelimeyi adeta podyuma çıkarıp hangilerinin aynı hizada en çok eşleştiğini bulmaya çalışan, biraz kafası karışık ama sonuç odaklı bir abimizdir. |
def wordBreak(s, wordDict):
dp = [False] * (len(s) + 1)
dp[len(s)] = True
for i in range(len(s) - 1, -1, -1):
for w in wordDict:
if (i + len(w)) <= len(s) and s[i:i + len(w)] == w:
dp[i] = dp[i + len(w)]
if dp[i]:
break
return dp[0] | Dinamik programlama kullanarak metnin verilen sözlükteki kelimelerle parçalanıp parçalanamayacağını kontrol eder. Sanki her harf bir bilmeceymiş gibi, sondan başa giderek "buradan sonrası kurtarır mı?" diye sorgulayan, oldukça kararsız ama iş bitirici bir fonksiyondur. |
def combinationSum(candidates, target):
res = []
def dfs(i, cur, total):
if total == target:
res.append(cur.copy())
return
if i >= len(candidates) or total > target:
return
cur.append(candidates[i])
dfs(i, cur, total + candidates[i])
cu... | Verilen listedeki sayıları kullanarak toplamı hedefe ulaştıran tüm kombinasyonları bulmak için derinlemesine arama yapan backtracking algoritmasıdır. Bu fonksiyon sanki mutfakta "hangi malzemeleri birleştirirsem tam on gram eder" diye sürekli kendini tekrar edip kafayı yiyen bir ev hanımı gibi çalışıyor. |
def permute(nums):
res = []
if len(nums) == 1:
return [nums[:]]
for i in range(len(nums)):
n = nums.pop(0)
perms = permute(nums)
for perm in perms:
perm.append(n)
res.extend(perms)
nums.append(n)
return res | Verilen listenin tüm olası sıralanış kombinasyonlarını recursive bir mantıkla üreten, listenin eleman sayısını görünce işlemciyi biraz terletebilecek bir fonksiyon. Kendi kendine dönüp duran bu döngü, elemanları tek tek yer değiştirerek tüm varyasyonları bulana kadar durmak bilmiyor. |
def subsets(nums):
res = []
subset = []
def dfs(i):
if i >= len(nums):
res.append(subset.copy())
return
subset.append(nums[i])
dfs(i + 1)
subset.pop()
dfs(i + 1)
dfs(0)
return res | Verilen kümenin tüm olası alt kümelerini oluşturan, kombinasyonların dibine vuran bir DFS algoritmasıdır. Liste içindeki her elemanı ya aldım ya da almadım diyerek kendi kendine konuşup duran, kararsızlığıyla meşhur bir arkadaştır. |
def letterCombinations(digits):
if not digits: return []
phone = {'2':'abc', '3':'def', '4':'ghi', '5':'jkl', '6':'mno', '7':'pqrs', '8':'tuv', '9':'wxyz'}
res = []
def backtrack(i, curStr):
if len(curStr) == len(digits):
res.append(curStr)
return
for c in phone[d... | Eski tuşlu telefonlardaki harf kombinasyonlarını backtrack yöntemiyle bulan, kombinasyon meraklısı fonksiyon. Sanki o günlere dönüp mesaj yazacakmışız gibi, girilen her rakama karşılık gelen tüm harf ihtimallerini eşleştirip bize listeliyor. |
def generateParenthesis(n):
stack, res = [], []
def backtrack(openN, closedN):
if openN == closedN == n:
res.append("".join(stack))
return
if openN < n:
stack.append("(")
backtrack(openN + 1, closedN)
stack.pop()
if closedN < op... | Verilen n sayısı kadar parantezi, tüm kombinasyonların geçerli olacak şekilde (açılan kapanmalı) sıralayan backtrack algoritması. Bilgisayarın kendi kendine "şunu koysam mı, bunu kapatsam mı" diye kararsızlık yaşayıp sonunda tüm olası senaryoları önümüze seren bitmek bilmez bir merak fonksiyonu. |
def canJump(nums):
goal = len(nums) - 1
for i in range(len(nums) - 1, -1, -1):
if i + nums[i] >= goal:
goal = i
return goal == 0 | Listenin sonuna ulaşıp ulaşamayacağınızı anlamak için sondan başa doğru zıplama mesafelerini kontrol eden bir algoritma. Eğer hedefe kadar gidebiliyorsanız ilk indekse kadar yolu yarılamışsınız demektir, değilse baştan pes edip kaldınız demektir. |
def merge(intervals):
intervals.sort(key=lambda i: i[0])
output = [intervals[0]]
for start, end in intervals[1:]:
lastEnd = output[-1][1]
if start <= lastEnd:
output[-1][1] = max(lastEnd, end)
else:
output.append([start, end])
return output | Önce aralıkları başlangıç noktalarına göre sıralayıp, birbirine girenleri tek bir aralıkta birleştiren teknik bir fonksiyon. Kendi aralıklarını yönetemeyen o karmaşık zaman dilimlerini alıp, "sizin derdiniz ne" diyerek düzenleyen bir nevi yazılımcı terapisti kendisi. |
def insert(intervals, newInterval):
res = []
for i in range(len(intervals)):
if newInterval[1] < intervals[i][0]:
res.append(newInterval)
return res + intervals[i:]
elif newInterval[0] > intervals[i][1]:
res.append(intervals[i])
else:
newIn... | Sıralı aralık listesine yeni bir aralık eklerken çakışanları birleştirip düzenli bir liste döndürür. Sanki trafikte araya kaynak yapmaya çalışan arabaları görüp, birbirine girenleri tek bir tır haline getiren trafik polisi gibi bir fonksiyon. |
def eraseOverlapIntervals(intervals):
intervals.sort(key=lambda i: i[1])
res = 0
prevEnd = intervals[0][1]
for start, end in intervals[1:]:
if start >= prevEnd:
prevEnd = end
else:
res += 1
return res | Aralıkları bitiş sürelerine göre sıralayıp çakışanları temizleyen ve kaç tanesini çöpe attığımızı sayan bir fonksiyon. Etkinlik takviminde birbirine giren toplantıları ayıklarken "yine mi çakıştık" diye sinirlenen proje yöneticisi gibi çalışıyor. |
def rotate(matrix):
matrix.reverse()
for i in range(len(matrix)):
for j in range(i):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j] | Matrisi önce ters çevirip sonra transpozunu alarak 90 derece döndüren bu arkadaş, aslında matrise spor salonunda takla attırıyor. Satır ve sütunların yerini değiştirip matrisi döndürürken, insanın da kafasını döndüren ama teknik olarak oldukça temiz bir işlemdir. |
def spiralOrder(matrix):
res = []
left, right = 0, len(matrix[0])
top, bottom = 0, len(matrix)
while left < right and top < bottom:
for i in range(left, right): res.append(matrix[top][i])
top += 1
for i in range(top, bottom): res.append(matrix[i][right - 1])
right -= 1
... | Matrisi dışarıdan merkeze doğru halkalar çizerek dolaşan, adeta bir salyangoz gibi kıvrılan bu fonksiyon matrisin elemanlarını spiral bir sırayla listeler. Köşeleri döndükçe kendi sınırlarını daraltan bu arkadaş, labirentte kaybolmaya ant içmiş gibi bir hal sergiliyor. |
def setZeroes(matrix):
ROWS, COLS = len(matrix), len(matrix[0])
rowZero = False
for r in range(ROWS):
for c in range(COLS):
if matrix[r][c] == 0:
matrix[0][c] = 0
if r > 0: matrix[r][0] = 0
else: rowZero = True
for r in range(1, ROWS):
... | Matris içinde bir tane bile sıfır bulursa, o sıfırın bulunduğu tüm satır ve sütunu silip süpürerek sıfıra eşitleyen fonksiyon. Kendi hafızasını kullanarak extra alan harcamamaya çalışıyor, yani resmen evdeki malzemelerle kıtlıktan çıkan bir aşçı gibi çalışıyor. |
def sortColors(nums):
l, i, r = 0, 0, len(nums) - 1
while i <= r:
if nums[i] == 0:
nums[l], nums[i] = nums[i], nums[l]
l += 1; i += 1
elif nums[i] == 2:
nums[i], nums[r] = nums[r], nums[i]
r -= 1
else:
i += 1 | Dijkstra'nın meşhur Dutch National Flag problemini çözen bu kod, 0, 1 ve 2 değerlerini içeren bir listeyi sıralar. Listenin içine girip 0'ları başa, 2'leri sona şutlayan, 1'leri de ortada kendi haline bırakan tam bir OKB hastasıdır kendisi. |
def longestPalindrome(s):
res, resLen = "", 0
for i in range(len(s)):
l, r = i, i
while l >= 0 and r < len(s) and s[l] == s[r]:
if (r - l + 1) > resLen:
res = s[l:r+1]
resLen = r - l + 1
l -= 1; r += 1
l, r = i, i + 1
while ... | String içindeki olası tüm palindromları merkezden dışa doğru tarayarak en uzununu bulan, Expand Around Center yöntemini kullanan fonksiyon. Neredeyse tüm kelimeyi didik didik edip "acaba tersi de aynı mı" diye soran, mükemmelliyetçi bir arkadaş. |
def countSubstrings(s):
res = 0
for i in range(len(s)):
l = r = i
while l >= 0 and r < len(s) and s[l] == s[r]:
res += 1; l -= 1; r += 1
l = i; r = i + 1
while l >= 0 and r < len(s) and s[l] == s[r]:
res += 1; l -= 1; r += 1
return res | Verilen metin içindeki tüm olası palindrom alt dizilerini bulmak için merkezi genişletme yöntemini kullanır. Ortadan dışa doğru "ben aynısıyım, sen de aynısısın" diyerek birbirini onaylayan karakterleri sayıp duran, kendi kendine gelin güvey olan bir fonksiyon. |
def findAnagrams(s, p):
if len(p) > len(s): return []
pCount, sCount = {}, {}
for i in range(len(p)):
pCount[p[i]] = 1 + pCount.get(p[i], 0)
sCount[s[i]] = 1 + sCount.get(s[i], 0)
res = [0] if sCount == pCount else []
l = 0
for r in range(len(p), len(s)):
sCount[s[r]] = 1... | Sliding window mantığıyla ana metin içerisinde aranan kelimenin tüm harf kombinasyonlarını tarayıp başlangıç indekslerini döndürür. Kelime avında harflerin yerini karıştırıp aynı harf setini tutturmaya çalışan, biraz manyak bir fonksiyon. |
def characterReplacement(s, k):
count = {}
res, l = 0, 0
maxf = 0
for r in range(len(s)):
count[s[r]] = 1 + count.get(s[r], 0)
maxf = max(maxf, count[s[r]])
while (r - l + 1) - maxf > k:
count[s[l]] -= 1
l += 1
res = max(res, r - l + 1)
return ... | Sliding window algoritması ile metin içinde en fazla K adet karakter değiştirerek oluşturulabilecek en uzun aynı karakterli dizinin boyunu hesaplar. Sadece harfleri değiştirip zengin gibi davranan bu fonksiyon, aslında elindeki malzemeyi en verimli nasıl kullanırım diye kılı kırk yaran tam bir hesap kitap uzmanı. |
import collections
def isValidSudoku(board):
cols = collections.defaultdict(set)
rows = collections.defaultdict(set)
squares = collections.defaultdict(set)
for r in range(9):
for c in range(9):
if board[r][c] == '.': continue
if (board[r][c] in rows[r] or
... | Sudoku tahtasındaki her satır, sütun ve 3x3'lük kutucukta rakam tekrarı olup olmadığını kontrol eden bir dedektif fonksiyonudur. Eğer bir rakamı aynı bölgede ikinci kez görürse, "yok artık daha neler" diyerek hemen false cevabını yapıştırır. |
def evalRPN(tokens):
stack = []
for c in tokens:
if c == "+":
stack.append(stack.pop() + stack.pop())
elif c == "-":
a, b = stack.pop(), stack.pop()
stack.append(b - a)
elif c == "*":
stack.append(stack.pop() * stack.pop())
elif c =... | Ters Polonya Notasyonu (RPN) ile yazılmış matematiksel ifadeleri, sayıları bir yığına atıp işlemcileri görünce en son eklenen iki sayıyı işleme sokarak çözen algoritmadır. Sanki hesap makinesini ters çevirip kullanmaya çalışan inatçı bir bilgisayar gibi davranıyor, işlem sırasını parantezlerle değil yığının derinliğiyl... |
def dailyTemperatures(temperatures):
res = [0] * len(temperatures)
stack = []
for i, t in enumerate(temperatures):
while stack and t > stack[-1][0]:
stackT, stackInd = stack.pop()
res[stackInd] = i - stackInd
stack.append((t, i))
return res | Sıcaklıkları bir yığına alıp kendisinden yüksek olanı bulana kadar bekleten, Monotonik Stack algoritmasını kullanan bir takip mekanizmasıdır. Bu fonksiyon, havaların ısınmasını dört gözle bekleyen ama sonunda kendi sıcaklığıyla baş başa kalan o yalnız rakamların günlerini sayar. |
import math
def minEatingSpeed(piles, h):
l, r = 1, max(piles)
res = r
while l <= r:
k = (l + r) // 2
hours = sum(math.ceil(p / k) for p in piles)
if hours <= h:
res = min(res, k)
r = k - 1
else:
l = k + 1
return res | Binary search algoritmasını kullanarak, eldeki muzları belirlenen sürede bitirecek en düşük yeme hızını bulur. Maymunun acıkınca hızı artırıp yorulunca hızı düşürdüğü, tam bir denge oyunu kuran fonksiyonumuz. |
def searchMatrix(matrix, target):
ROWS, COLS = len(matrix), len(matrix[0])
top, bot = 0, ROWS - 1
while top <= bot:
row = (top + bot) // 2
if target > matrix[row][-1]: top = row + 1
elif target < matrix[row][0]: bot = row - 1
else: break
if not (top <= bot): return False
... | İki aşamalı binary search kullanarak matris içinde hedef sayıyı arayan, satırları ve sütunları tek tek tarayıp vakit kaybetmeyen verimli bir arkadaş. Matrisin içinde kaybolmadan doğrudan hedefi bulan bu fonksiyon, sanki Google Haritalar'da adres arar gibi çat diye konuma gidiyor. |
def findPeakElement(nums):
l, r = 0, len(nums) - 1
while l < r:
m = l + ((r - l) // 2)
if nums[m] > nums[m + 1]:
r = m
else:
l = m + 1
return l | Binary search mantığını kullanarak listedeki komşularından daha büyük olan bir tepe noktasını bulan fonksiyon. Dağdaki oksijenin azlığından mıdır nedir, sadece tek bir zirve bulup hemen eve dönüyor, macera sevmiyor. |
import heapq
def findKthLargest(nums, k):
min_heap = nums[:k]
heapq.heapify(min_heap)
for num in nums[k:]:
if num > min_heap[0]:
heapq.heappushpop(min_heap, num)
return min_heap[0] | Min-heap kullanarak listenin en büyük k-ıncı elemanını bulur. Tüm listeyi sıralamakla uğraşıp zaman kaybetmek yerine, sadece k kadar elemanla ilgilenen bu fonksiyon tam bir iş bitirici. |
import heapq
def lastStoneWeight(stones):
stones = [-s for s in stones]
heapq.heapify(stones)
while len(stones) > 1:
first = heapq.heappop(stones)
second = heapq.heappop(stones)
if second > first:
heapq.heappush(stones, first - second)
return abs(stones[0]) if stones ... | En büyük iki taşı alıp birbirine vurdurarak parçalayan, sürekli en büyükleri kapıştırmaktan keyif alan bir yıkım ustasıdır. Heapq kullanarak sayıları negatif yapıp maksimum değerleri çekiyor, sanki mahallede en ağır abileri dövüştürüyoruz. |
import heapq
def kClosest(points, k):
minHeap = []
for x, y in points:
dist = (x ** 2) + (y ** 2)
minHeap.append([dist, x, y])
heapq.heapify(minHeap)
res = []
while k > 0:
dist, x, y = heapq.heappop(minHeap)
res.append([x, y])
k -= 1
return res | Noktaların orijine olan uzaklıklarını hesaplayıp `heapq` ile en yakın k tanesini seçen fonksiyon. Kendi kendine mesafe ölçüp "en yakın benim, gelsin bakalım paralar" diyen egoist noktalarla uğraşıyoruz yine. |
def numDecodings(s):
dp = {len(s): 1}
for i in range(len(s) - 1, -1, -1):
if s[i] == "0":
dp[i] = 0
else:
dp[i] = dp[i + 1]
if (i + 1 < len(s) and (s[i] == "1" or (s[i] == "2" and s[i + 1] in "0123456"))):
dp[i] += dp[i + 2]
return dp[0] | Bu fonksiyon, verilen sayı dizisinin harf karşılıklarıyla kaç farklı şekilde yorumlanabileceğini dinamik programlama ile hesaplıyor. Sanki şifreli bir mesajı çözerken her adımda ''acaba bu harf mi yoksa birleşip şu harf mi olur'' diye kararsız kalan birinin kafa karışıklığını kod dökmüşler. |
def generateMatrix(n):
mat = [[0] * n for _ in range(n)]
left, right, top, bottom = 0, n - 1, 0, n - 1
val = 1
while left <= right and top <= bottom:
for i in range(left, right + 1): mat[top][i] = val; val += 1
top += 1
for i in range(top, bottom + 1): mat[i][right] = val; val +=... | Sarmal bir yapıda n x n boyutunda bir matrisi 1'den başlayarak içe doğru doldurur. Sanki bir labirentin ortasına ulaşmaya çalışıyormuş gibi tüm kenarları tek tek dönüp bitiren, işsiz güçsüz bir fonksiyon. |
def isSameTree(p, q):
if not p and not q: return True
if not p or not q or p.val != q.val: return False
return isSameTree(p.left, q.left) and isSameTree(p.right, q.right) | İki ağaç yapısının hem düğüm değerlerini hem de çocuklarını özyinelemeli (recursive) olarak karşılaştırarak tıpatıp aynı olup olmadıklarını kontrol eder. Biri diğerinin kopyası mı yoksa sadece birbirine hava mı atıyor diye didik didik eden bir lavuktur kendisi. |
def twoSum(nums, target):
prevMap = {}
for i, n in enumerate(nums):
diff = target - n
if diff in prevMap:
return [prevMap[diff], i]
prevMap[n] = i
return [] | Verilen listedeki sayıları tek tek dolaşarak, hedef sayıya ulaşmamızı sağlayan ikiliyi hash map kullanarak bulan popüler bir algoritmadır. İç içe döngü kurup bilgisayarı yormadan, tek seferde işi çözen oldukça çevik bir abimizdir. |
def addTwoNumbers(l1, l2):
dummy = ListNode()
curr = dummy
carry = 0
while l1 or l2 or carry:
v1 = l1.val if l1 else 0
v2 = l2.val if l2 else 0
val = v1 + v2 + carry
carry = val // 10
val = val % 10
curr.next = ListNode(val)
curr = curr.next
... | İki farklı linked list yapısındaki sayıları basamak basamak toplayan ve elde varsa bir sonraki düğüme taşıyan fonksiyon. Sanki ilkokulda alt alta toplama işlemi yapıyormuşuz gibi, eldeki sayıları bir türlü rahat bırakmayan komutan edasıyla çalışıyor. |
def lengthOfLongestSubstring(s):
charSet = set()
l = 0
res = 0
for r in range(len(s)):
while s[r] in charSet:
charSet.remove(s[l])
l += 1
charSet.add(s[r])
res = max(res, r - l + 1)
return res | Sliding Window algoritması kullanarak bir metin içindeki tekrar etmeyen en uzun karakter dizisinin uzunluğunu bulur. Sanki çok dolu bir otobüste kendine yer arayan yolcu gibi, karakterleri setin içine yerleştirip çakışma olunca baştakini kapı dışarı ediyor. |
def findMedianSortedArrays(nums1, nums2):
A, B = nums1, nums2
total = len(nums1) + len(nums2)
half = total // 2
if len(B) < len(A):
A, B = B, A
l, r = 0, len(A) - 1
while True:
i = (l + r) // 2
j = half - i - 2
Aleft = A[i] if i >= 0 else float('-infinity')
... | Binary search algoritmasını kullanarak iki sıralı diziyi birleştirilmiş gibi görüp medyanı bulan, biraz karmaşık bir yapıya sahip fonksiyon. İki listeyi tek tek birleştirmeye üşenenlerin, hayatı kendine zorlaştırmak isteyenlerin başvurduğu tam bir mühendislik şovu. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.