code stringlengths 35 1.46k | explanation stringlengths 152 368 |
|---|---|
def reverse(x):
MIN, MAX = -2**31, 2**31 - 1
res = 0
while x:
digit = int(math.fmod(x, 10))
x = int(x / 10)
if res > MAX // 10 or (res == MAX // 10 and digit >= MAX % 10):
return 0
if res < MIN // 10 or (res == MIN // 10 and digit <= MIN % 10):
return ... | Bir tam sayıyı basamaklarını tersine çevirerek döndüren, sınırları aşarsa da "yok artık daha neler" diyerek 0 dönen bir fonksiyon. 32-bit sınırlarını hesaplayıp taşma kontrolü yapmasıyla, boyundan büyük işlere kalkışan sayıları yola getiren sert bir müdür gibi çalışıyor. |
def isPalindrome(x):
if x < 0: return False
div = 1
while x >= 10 * div:
div *= 10
while x:
right = x % 10
left = x // div
if left != right: return False
x = (x % div) // 10
div = div / 100
return True | Bu kod, sayıları stringe çevirmeden matematiksel bölme ve mod alma işlemleriyle sayının baştan ve sondan aynı olup olmadığını kontrol eder. String kullanmadan "ben matematik biliyorum" diye hava atan, biraz uğraştıran ama işini tertemiz yapan bir arkadaşımızdır kendisi. |
def isMatch(s, p):
cache = {}
def dfs(i, j):
if (i, j) in cache: return cache[(i, j)]
if i >= len(s) and j >= len(p): return True
if j >= len(p): return False
match = i < len(s) and (s[i] == p[j] or p[j] == '.')
if (j + 1) < len(p) and p[j + 1] == '*':
cache[(... | Regular expression mantığıyla iki dizgenin eşleşip eşleşmediğini memoization kullanarak denetleyen, oldukça karmaşık bir fonksiyon. Kodun içine daldıkça labirentte kaybolmuş gibi hissettirse de, yıldız ve nokta karakterlerini yöneterek birbirlerini tamamlıyorlar. |
def maxArea(height):
l, r = 0, len(height) - 1
res = 0
while l < r:
area = (r - l) * min(height[l], height[r])
res = max(res, area)
if height[l] < height[r]: l += 1
else: r -= 1
return res | Two-pointer tekniğiyle listenin iki ucundan başlayarak en büyük alanı hesaplayan fonksiyon. İki duvar arasındaki mesafeyi ve kısa olanın boyunu çarparak kendine pay çıkarıyor, adeta en iyi manzaralı yeri bulmaya çalışan emlakçı gibi davranıyor. |
def intToRoman(num):
symList = [["I", 1], ["IV", 4], ["V", 5], ["IX", 9], ["X", 10], ["XL", 40], ["L", 50], ["XC", 90], ["C", 100], ["CD", 400], ["D", 500], ["CM", 900], ["M", 1000]]
res = ""
for sym, val in reversed(symList):
if num // val:
count = num // val
res += (sym * c... | Girdi olarak aldığı tam sayıyı, Roma rakamları tablosunda büyükten küçüğe doğru tarayarak eşdeğer sembol dizisine dönüştürür. Milattan önce Romalılar bu işi elle yaparken çok yorulmuştur, şimdi bizim işlemciyi terletiyorlar. |
def romanToInt(s):
roman = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
res = 0
for i in range(len(s)):
if i + 1 < len(s) and roman[s[i]] < roman[s[i + 1]]:
res -= roman[s[i]]
else:
res += roman[s[i]]
return res | Roma rakamlarını alıp standart sayı sistemine dönüştüren bu fonksiyon, sembollerin büyüklük sırasını kontrol ederek toplama veya çıkarma yapar. Roma halkının neden bu kadar zorlama bir sistem icat ettiğini sorgulatan, sayıları düzgünce çeviren bir çeviri ofisi gibi çalışıyor. |
def longestCommonPrefix(strs):
res = ""
for i in range(len(strs[0])):
for s in strs:
if i == len(s) or s[i] != strs[0][i]:
return res
res += strs[0][i]
return res | Listenin başındaki elemanı referans alıp diğer tüm kelimelerde aynı indekste ortak olan karakterleri bulan bir fonksiyon. Herkesin birbiriyle anlaştığı yere kadar gidip, ilk uyumsuzlukta "buraya kadar kardeş" diyerek kaçan sinsi bir arkadaş gibi çalışıyor. |
def threeSum(nums):
res = []
nums.sort()
for i, a in enumerate(nums):
if i > 0 and a == nums[i - 1]: continue
l, r = i + 1, len(nums) - 1
while l < r:
threeSum = a + nums[l] + nums[r]
if threeSum > 0: r -= 1
elif threeSum < 0: l += 1
el... | Listeyi sıralayıp üç sayının toplamının sıfır olduğu tüm kombinasyonları bulan, biraz zahmetli ama etkili bir fonksiyon. İçerideki while döngüleri ve işaretçilerle sanki bir dedektif gibi doğru üçlüyü arıyor, belli ki pek işi gücü yok. |
def threeSumClosest(nums, target):
nums.sort()
res = sum(nums[:3])
for i in range(len(nums) - 2):
l, r = i + 1, len(nums) - 1
while l < r:
s = nums[i] + nums[l] + nums[r]
if abs(s - target) < abs(res - target): res = s
if s < target: l += 1
eli... | Listenin içinden seçilen üç sayının toplamının hedeflenen sayıya en yakın olan değerini bulan, iki işaretçi yöntemini kullanan algoritmadır. Sanki markette üç ürün alıp toplamı cebimdeki paraya en yakın olsun diye kasada ecel terleri döken öğrenci gibi çalışıyor. |
def fourSum(nums, target):
nums.sort()
res, quad = [], []
def kSum(k, start, target):
if k != 2:
for i in range(start, len(nums) - k + 1):
if i > start and nums[i] == nums[i - 1]: continue
quad.append(nums[i])
kSum(k - 1, i + 1, target - nu... | Dört farklı sayının toplamının hedef değere eşit olduğu tüm benzersiz kombinasyonları bulan bir algoritma. Kodun karmaşıklığına bakınca sanki bakkal hesabı yapıyoruz ama işin içine recursion girince beyin hücrelerini biraz yakıyoruz. |
def removeNthFromEnd(head, n):
dummy = ListNode(0, head)
left = dummy
right = head
while n > 0 and right:
right = right.next
n -= 1
while right:
left = left.next
right = right.next
left.next = left.next.next
return dummy.next | İki işaretçiyi aralarında n kadar mesafe bırakarak ilerletip sondan n. düğümü silen, iki vitesli araba gibi çalışan bir yöntemdir. Sen sağdakiyle yolu arşınlarken soldakini geride bekletip, sona geldiğinde çaktırmadan düğümü aradan çıkartarak linked listi yeniden bağlayan sinsi bir düzenek. |
def isValid(s):
stack = []
closeToOpen = {")": "(", "]": "[", "}": "{"}
for c in s:
if c in closeToOpen:
if stack and stack[-1] == closeToOpen[c]:
stack.pop()
else:
return False
else:
stack.append(c)
return True if not s... | Verilen string içindeki parantezlerin birbiriyle eşleşip eşleşmediğini stack veri yapısını kullanarak kontrol eden algoritmadır. Sanki bulaşık makinesine tabak dizer gibi parantezleri yığıyor, açılanı kapatanla eşleşmezse "bu iş böyle olmaz" diyerek sistemi patlatıyor. |
def mergeTwoLists(list1, list2):
dummy = ListNode()
tail = dummy
while list1 and list2:
if list1.val < list2.val:
tail.next = list1
list1 = list1.next
else:
tail.next = list2
list2 = list2.next
tail = tail.next
if list1: tail.next =... | Sıralı iki bağlı listeyi, elemanları küçükten büyüğe olacak şekilde tek bir liste haline getirir. Listenin başına sahte bir düğüm koyup kuyruk takibi yaparak ilerleyen, işi bitince de artan parçayı ucuna ekleyen tam bir düzen hastası fonksiyon. |
def mergeKLists(lists):
if not lists or len(lists) == 0: return None
while len(lists) > 1:
mergedLists = []
for i in range(0, len(lists), 2):
l1 = lists[i]
l2 = lists[i + 1] if (i + 1) < len(lists) else None
mergedLists.append(mergeTwoLists(l1, l2))
li... | Sıralı listeleri ikili gruplar halinde birleştire birleştire tek bir dev liste oluşturan Divide and Conquer mantıklı bir algoritma. Sanki mahalledeki dağınık çocukları ikişerli eşleştirip sıraya dizerek sonunda tek bir orduya dönüştüren disiplinli bir öğretmen gibi çalışıyor. |
def swapPairs(head):
dummy = ListNode(0, head)
prev, curr = dummy, head
while curr and curr.next:
nxtPair = curr.next.next
second = curr.next
second.next = curr
curr.next = nxtPair
prev.next = second
prev = curr
curr = nxtPair
return dummy.next | Bağlı listedeki düğümleri ikişerli gruplar halinde birbirine çaprazlayarak yerlerini değiştiren bir fonksiyon. Liste içinde yer değiştirmece oynayan bu yaramaz, birbirini göremeyen düğümleri el ele tutuşturup sırayı birbirine katıyor. |
def reverseKGroup(head, k):
dummy = ListNode(0, head)
groupPrev = dummy
while True:
kth = getKth(groupPrev, k)
if not kth: break
groupNext = kth.next
prev, curr = kth.next, groupPrev.next
while curr != groupNext:
tmp = curr.next
curr.next = pre... | Bağlı listeyi k kadar gruplara ayırıp her grubun içini ters çeviren, hafıza yönetimini yoran karmaşık bir yapı. Kod yazarken kendimi neden bu kadar yorduğumu sorgulatan, k düğüm bulup sonra takla attıran tipik bir baş ağrısı fonksiyonu. |
def removeDuplicates(nums):
l = 1
for r in range(1, len(nums)):
if nums[r] != nums[r - 1]:
nums[l] = nums[r]
l += 1
return l | Sıralı bir dizideki tekrarlı sayıları atıp sadece benzersiz olanları öne yığan, Two Pointers algoritması kullanan bir fonksiyon. Sanki mahalledeki kalabalığı tek tek ayıklayıp sadece meşhur olanları düğüne davet eden titiz bir kapı görevlisi gibi çalışıyor. |
def removeElement(nums, val):
k = 0
for i in range(len(nums)):
if nums[i] != val:
nums[k] = nums[i]
k += 1
return k | Listenin içindeki istenmeyen değerleri silip kalanları başa dizerek yeni boyutu döndürür. Sanki bir partideki istenmeyen tipleri kapı dışarı edip, kalanları ön sıraya sıkıştıran organizatör gibi çalışan bir fonksiyon. |
def strStr(haystack, needle):
if needle == "": return 0
for i in range(len(haystack) + 1 - len(needle)):
if haystack[i: i + len(needle)] == needle:
return i
return -1 | Ana metin içerisinde aranan ifadeyi bulup ilk indeksini döndüren, biraz zahmetli ama işini bilen bir arama fonksiyonu. "Samanlıkta iğne aramak" deyimini koda dökmüşler, iğneyi bulamazsa da -1 verip "hadi başka kapıya" diyor. |
def divide(dividend, divisor):
d = abs(dividend)
dv = abs(divisor)
output = 0
while d >= dv:
tmp = dv
mul = 1
while d >= (tmp << 1):
tmp <<= 1
mul <<= 1
d -= tmp
output += mul
if (dividend < 0 and divisor >= 0) or (dividend >= 0 and div... | Bölme işlemini bit kaydırma yöntemleriyle yapan bu fonksiyon, işlemciye "bölmeyi ben senden daha hızlı yaparım" diye meydan okuyor. Bölünen sayıdan böleni sürekli çıkarıp sonucu toplayan bu arkadaş, en son 32-bit sınırına takılmamak için kendini frenlemeyi de ihmal etmiyor. |
def nextPermutation(nums):
i = len(nums) - 2
while i >= 0 and nums[i] >= nums[i + 1]:
i -= 1
if i >= 0:
j = len(nums) - 1
while nums[j] <= nums[i]:
j -= 1
nums[i], nums[j] = nums[j], nums[i]
nums[i+1:] = reversed(nums[i+1:]) | Listenin bir sonraki sözlük sırasındaki dizilimini bulan bu fonksiyon, önce artan düzeni bozan elemanı tespit edip yer değiştiriyor. Hayatında hiçbir şeyi planlayamayanlara inat, elindeki sayıları bir sonraki en büyük kombinasyona sokmak için kırk takla atan bir fonksiyon. |
def search(nums, target):
l, r = 0, len(nums) - 1
while l <= r:
mid = (l + r) // 2
if target == nums[mid]: return mid
if nums[l] <= nums[mid]:
if target > nums[mid] or target < nums[l]:
l = mid + 1
else:
r = mid - 1
else:
... | Döndürülmüş sıralı bir listede Binary Search yaparak hedef sayıyı bulan fonksiyon. Listenin yarısını çöpe atarak ilerlediği için, sanki sürekli bir şeyler saklıyormuş gibi çok gizemli takılan bir arkadaşımız. |
def searchRange(nums, target):
def binSearch(nums, target, leftBias):
l, r = 0, len(nums) - 1
i = -1
while l <= r:
m = (l + r) // 2
if target > nums[m]: l = m + 1
elif target < nums[m]: r = m - 1
else:
i = m
if l... | Binary search algoritmasını kullanarak sıralı bir dizideki hedef sayının başlangıç ve bitiş indekslerini bulan, arama yapmaktan sıkılınca sınırları sürekli daraltan bir fonksiyon. Listenin içinde hedefi ararken sağına soluna bakıp "burası mı, yoksa şurası mı" diye kararsız kalan bir dedektif gibi çalışıyor. |
def solveSudoku(board):
def isValid(r, c, k):
for i in range(9):
if board[i][c] == k or board[r][i] == k or board[3 * (r // 3) + i // 3][3 * (c // 3) + i % 3] == k:
return False
return True
def solve():
for r in range(9):
for c in range(9):
... | Sudoku tahtasındaki boşlukları "acaba buraya ne koysam" diye deneyerek dolduran backtracking algoritmasıdır. Bir yandan rakamları yerleştirip diğer yandan kuralları çiğnedin mi diye kontrol eden, hata yapınca da başa saran epey sabırlı bir arkadaş kendisi. |
def countAndSay(n):
if n == 1: return "1"
prev = countAndSay(n - 1)
res = ""
count = 1
for i in range(len(prev)):
if i == len(prev) - 1 or prev[i] != prev[i + 1]:
res += str(count) + prev[i]
count = 1
else:
count += 1
return res | Önceki adımın sonucunu alıp karakterlerin tekrar sayısını ve kendisini birleştirerek yeni bir dizi oluşturan, recursive çalışan bir fonksiyon. İnsanın kendi kendine sürekli "kaç tane var, ne var" diye sayıklayıp durmasına neden olan, tam bir obsesif kompozisyon çalışması. |
def combinationSum2(candidates, target):
candidates.sort()
res = []
def backtrack(cur, pos, target):
if target == 0:
res.append(cur.copy())
return
if target <= 0:
return
prev = -1
for i in range(pos, len(candidates)):
if candida... | Backtracking algoritması kullanarak verilen listedeki sayıları farklı kombinasyonlarla toplayıp hedef değere ulaşmaya çalışır ve kopyaları ayıklamak için sort işlemini kullanır. Hedefi tutturamayınca listeyi geri alıp saç baş yolduran, kombinasyon avcısı bir fonksiyon. |
def firstMissingPositive(nums):
for i in range(len(nums)):
if nums[i] < 0: nums[i] = 0
for i in range(len(nums)):
val = abs(nums[i])
if 1 <= val <= len(nums):
if nums[val - 1] > 0:
nums[val - 1] *= -1
elif nums[val - 1] == 0:
nums[v... | Dizideki eksik olan en küçük pozitif tam sayıyı bulan, elemanları işaretleyerek hafızayı verimli kullanan bir algoritmadır. Sayılarla bu kadar oynayıp negatif yapmak yerine direkt bir sete atsanıza diye içimden geçmiyor değil ama neyse. |
def trap(height):
if not height: return 0
l, r = 0, len(height) - 1
leftMax, rightMax = height[l], height[r]
res = 0
while l < r:
if leftMax < rightMax:
l += 1
leftMax = max(leftMax, height[l])
res += leftMax - height[l]
else:
r -= 1
... | Two-pointer yöntemini kullanarak çukurlarda biriken su miktarını hesaplayan, adeta bir mühendislik harikası gibi su tesisatçılığı yapan bir fonksiyon. İki taraftan sıkıştırarak suyun kaçabileceği delikleri kapatıyor, yoksa o suyun hepsi ziyan olup gidecek. |
def multiply(num1, num2):
if "0" in [num1, num2]: return "0"
res = [0] * (len(num1) + len(num2))
num1, num2 = num1[::-1], num2[::-1]
for i1 in range(len(num1)):
for i2 in range(len(num2)):
digit = int(num1[i1]) * int(num2[i2])
res[i1 + i2] += digit
res[i1 + i2... | String formatındaki iki büyük sayıyı çarpma işlemini, okulda öğrendiğimiz klasik çarpma yöntemini bir dizi üzerinde simüle ederek gerçekleştirir. Sayılarla tek tek uğraşmak yerine dizide elde tutarak işlem yapması, ilkokulda alt alta çarpım yaparken eldeki sayıyı unutup öğretmenden azar yiyen öğrenciyi hatırlatıyor. |
def jump(nums):
res = 0
l = r = 0
while r < len(nums) - 1:
farthest = 0
for i in range(l, r + 1):
farthest = max(farthest, i + nums[i])
l = r + 1
r = farthest
res += 1
return res | Greedy yaklaşım kullanarak listenin sonuna en az adımda nasıl gidileceğini hesaplayan bu fonksiyon, her hamlede ileriye en çok zıplatan yeri seçiyor. Hayatın her alanında bu kadar planlı olsanız şimdiye çoktan köşeyi dönmüştünüz, bari kodlarınızda bu vizyonu gösterin. |
def permuteUnique(nums):
res = []
nums.sort()
def backtrack(comb, counter):
if len(comb) == len(nums):
res.append(list(comb))
return
for num in counter:
if counter[num] > 0:
comb.append(num)
counter[num] -= 1
... | Verilen sayı listesinin tüm benzersiz permütasyonlarını backtrack kullanarak üreten, işlem yüküyle sizi gece uykusuz bırakacak bir fonksiyon. Kendi kendine sürekli dönüp duran bu arkadaş, elindeki sayılar bitene kadar kombinasyon üretip kafayı yeme potansiyeline sahip. |
import collections
def groupAnagrams(strs):
ans = collections.defaultdict(list)
for s in strs:
count = [0] * 26
for c in s:
count[ord(c) - ord('a')] += 1
ans[tuple(count)].append(s)
return list(ans.values()) | Kelime içindeki harflerin frekanslarını sayıp aynı harf dizilimine sahip olanları gruplayan, anagram avcısı bir fonksiyon. İçerideki karakter sayılarını anahtar olarak kullanarak, birbirinin değişik versiyonu olan kelimeleri aynı odaya kapatıyor. |
def myPow(x, n):
def helper(x, n):
if x == 0: return 0
if n == 0: return 1
res = helper(x, n // 2)
res = res * res
return x * res if n % 2 else res
res = helper(x, abs(n))
return res if n >= 0 else 1 / res | X sayısının N'inci kuvvetini binary exponentiation yöntemiyle hesaplar. Böl ve yönet mantığıyla çalışıp işlem yükünü azaltıyor ama bizim junior yazılımcı yine de gidip `x ** n` yazmak varken niye bunu kullansın, hayret doğrusu. |
def solveNQueens(n):
col = set(); posDiag = set(); negDiag = set()
res = []; board = [["."] * n for _ in range(n)]
def backtrack(r):
if r == n:
copy = ["".join(row) for row in board]
res.append(copy)
return
for c in range(n):
if c in col or (r ... | N-Queens problemini backtracking yöntemiyle çözerek, vezirlerin birbirini yemeyeceği tüm tahta dizilimlerini bulan algoritmadır. Satrançta kendi başının çaresine bakamayan vezirleri güvenle yerleştirmek için uğraşan, hayatı hamle yapıp geri almaktan ibaret olan o meşhur fonksiyon işte bu. |
def maxSubArray(nums):
res = nums[0]
total = 0
for n in nums:
if total < 0:
total = 0
total += n
res = max(res, total)
return res | Kadane algoritmasını kullanarak dizideki bitişik elemanların toplamından elde edilebilecek en büyük değeri hesaplar. Listenin içinde negatif sayılar yüzünden moral bozup toplamı sıfırlayan, ama yine de en iyi sonucu bulmak için inat eden azimli bir fonksiyon. |
def lengthOfLastWord(s):
i, length = len(s) - 1, 0
while s[i] == " ": i -= 1
while i >= 0 and s[i] != " ":
length += 1
i -= 1
return length | Metnin sonundaki boşlukları görmezden gelip en sonda yer alan kelimenin karakter sayısını hesaplar. Cümle sonundaki gereksiz boşlukları temizleyip asıl işe odaklanan, tam bir dikkat dağınıklığı düşmanı fonksiyondur. |
def uniquePaths(m, n):
row = [1] * n
for i in range(m - 1):
newRow = [1] * n
for j in range(n - 2, -1, -1):
newRow[j] = newRow[j + 1] + row[j]
row = newRow
return row[0] | m x n boyutundaki bir ızgarada, başlangıçtan bitişe kaç farklı yolla gidilebileceğini dinamik programlama kullanarak hesaplayan fonksiyondur. Kendi kendine "sağdan mı gitsem yoksa aşağıdan mı" diye karar veremeyen, elindeki tüm ihtimalleri toplayıp sonucu bulan kararsız bir beyin gibi çalışıyor. |
def uniquePathsWithObstacles(obstacleGrid):
M, N = len(obstacleGrid), len(obstacleGrid[0])
dp = [0] * N
dp[N-1] = 1
for r in reversed(range(M)):
for c in reversed(range(N)):
if obstacleGrid[r][c]: dp[c] = 0
elif c + 1 < N: dp[c] = dp[c] + dp[c+1]
return dp[0] | Dynamic programming kullanarak engelli bir ızgarada başlangıçtan bitişe kaç farklı yolla gidilebileceğini hesaplar. Yolda engel varsa direkt yolu kapatıyor, yani bizim robot engelleri görünce "burası kapalı hocam" deyip yolunu değiştiriyor, ne yapalım hayat hep düz yol değil. |
def minPathSum(grid):
ROWS, COLS = len(grid), len(grid[0])
res = [[float("inf")] * (COLS + 1) for r in range(ROWS + 1)]
res[ROWS - 1][COLS] = 0
for r in range(ROWS - 1, -1, -1):
for c in range(COLS - 1, -1, -1):
res[r][c] = grid[r][c] + min(res[r + 1][c], res[r][c + 1])
return re... | Dinamik programlama kullanarak bir ızgara içindeki en küçük toplamlı yolu bulur. Sanki labirentte en az borçla çıkışı arayan bir öğrenci gibi, her adımda sağdan veya aşağıdan gelen en küçük maliyeti seçip ilerliyor. |
def plusOne(digits):
digits = digits[::-1]
one, i = 1, 0
while one:
if i < len(digits):
if digits[i] == 9:
digits[i] = 0
else:
digits[i] += 1
one = 0
else:
digits.append(1)
one = 0
i += 1
... | Rakamlardan oluşan bir listenin sonuna 1 ekleyip sayısal toplamı güncelleyen bu fonksiyon, elde var bir durumunda listeyi uzatmayı da ihmal etmiyor. Dokuzları sıfırlayıp bir üst basamağa taşıma konusunda, sanki ilkokul matematik sınavındaki o bitmek bilmeyen elden toplamaları yapan gıcık bir hoca gibi davranıyor. |
def addBinary(a, b):
res = ""
carry = 0
a, b = a[::-1], b[::-1]
for i in range(max(len(a), len(b))):
digitA = ord(a[i]) - ord("0") if i < len(a) else 0
digitB = ord(b[i]) - ord("0") if i < len(b) else 0
total = digitA + digitB + carry
char = str(total % 2)
res = c... | İki binary string'i toplayıp sonucu yine binary formatında döndüren, ilkokul toplama işlemini biraz fazla ciddiye alan bir fonksiyon. Elde var bir kuralını uygulayarak bitleri tek tek topluyor, sanki işlemciyi kendi ellerimizle kodluyoruz. |
def mySqrt(x):
l, r = 0, x
res = 0
while l <= r:
m = l + ((r - l) // 2)
if m**2 > x:
r = m - 1
elif m**2 < x:
l = m + 1
res = m
else:
return m
return res | Binary search algoritması kullanarak bir sayının karekökünü tam sayı kısmına kadar hesaplayan fonksiyon. Sayıyı bulana kadar aralık daraltıp duruyor, sanki evde kaybolan çorabını arayan ben. |
def climbStairs(n):
one, two = 1, 1
for i in range(n - 1):
temp = one
one = one + two
two = temp
return one | Basamakları birer veya ikişer çıkarak tepeye ulaşmanın kaç farklı yolu olduğunu hesaplayan, Fibonacci dizisini temel alan dinamik bir algoritma. Sanki merdivenleri değil de kendi kariyer basamaklarını çıkıyormuş gibi, her adımda önceki iki durumun toplamını hafızasında tutan tam bir hesap kitap uzmanı. |
def simplifyPath(path):
stack = []
cur = ""
for c in path + "/":
if c == "/":
if cur == "..":
if stack: stack.pop()
elif cur != "" and cur != ".":
stack.append(cur)
cur = ""
else:
cur += c
return "/" + "/".jo... | Verilen dosya yolunu parçalara ayırıp gereksiz noktaları ve üst dizin komutlarını temizleyerek en sade haline getirir. Yazılım dünyasının "dosya karmaşası temizleme" servisi gibi çalışıp, gereksiz her şeyi ayıklayarak seni o büyük kafa karışıklığından kurtaran bir fonksiyondur. |
def minDistance(word1, word2):
dp = [[float("inf")] * (len(word2) + 1) for i in range(len(word1) + 1)]
for j in range(len(word2) + 1):
dp[len(word1)][j] = len(word2) - j
for i in range(len(word1) + 1):
dp[i][len(word2)] = len(word1) - i
for i in range(len(word1) - 1, -1, -1):
for... | Edit distance algoritması, iki metni birbirine eşitlemek için gereken minimum ekleme, silme ve değiştirme hamle sayısını hesaplar. Kelimeler üzerinde o kadar çok ameliyat yapıyor ki sonunda geriye sadece bir harf kalsa o bile kendini tanıyamaz hale geliyor. |
def exist(board, word):
ROWS, COLS = len(board), len(board[0])
path = set()
def dfs(r, c, i):
if i == len(word): return True
if (r < 0 or c < 0 or r >= ROWS or c >= COLS or word[i] != board[r][c] or (r, c) in path): return False
path.add((r, c))
res = (dfs(r + 1, c, i + 1) or... | Harfler arasında gezinip derinlemesine arama yapan ve DFS algoritmasını kullanarak kelimeyi bulmaya çalışan bir fonksiyon. Labirentte kaybolmuş bir turist gibi her köşeyi kontrol ediyor, eğer doğru yolu bulamazsa başladığı yere geri dönüyor. |
def hammingWeight(n):
res = 0
while n:
res += n & 1
n >>= 1
return res | Verilen sayının ikilik sistemdeki temsilinde kaç tane 1 rakamı olduğunu sayan bir fonksiyondur. Sayıyı sağa doğru kaydırıp 1'leri ayıklarken sanki bir sayım memuru gibi mesai harcıyor, arkadaşın derdi belli ki bitmeyen bitlerle uğraşmak. |
def countBits(n):
dp = [0] * (n + 1)
for i in range(1, n + 1):
dp[i] = dp[i >> 1] + (i & 1)
return dp | 0'dan n'e kadar her sayının ikilik tabandaki birlerinin toplamını dinamik programlama ile hesaplayan fonksiyon. Kendi kendine yeten bu yöntemle, sayının yarısının bit sayısına son basamağını ekleyerek işi tek hamlede çözüyor, biz de oturup bit sayıyoruz. |
def reverseBits(n):
res = 0
for i in range(32):
bit = (n >> i) & 1
res = res | (bit << (31 - i))
return res | 32 bitlik bir sayının bitlerini tamamen tersine çevirerek yeni bir değer oluşturur. Yazılım dünyasında bitlerle oynamak kadar anlamsız bir uğraş daha görmedim, sanki 32 bitin yeri değişince dünya kurtuluyor. |
def firstMissingPositive(nums):
n = len(nums)
for i in range(n):
while 1 <= nums[i] <= n and nums[nums[i] - 1] != nums[i]:
nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
for i in range(n):
if nums[i] != i + 1:
return i + 1
return n + 1 | Sayıları kendi indeks değerlerine göre dizerek eksik olan en küçük pozitif tam sayıyı bulan bir sıralama numarasıdır. Liste içinde saklambaç oynayan sayıları yakalayıp yerlerine oturtmaya çalışan bu arkadaş, bulamadığı ilk boş koltukta hemen fişi çekiyor. |
def trap(height):
l, r = 0, len(height) - 1
leftMax, rightMax = height[l], height[r]
res = 0
while l < r:
if leftMax < rightMax:
l += 1
leftMax = max(leftMax, height[l])
res += leftMax - height[l]
else:
r -= 1
rightMax = max(rig... | İki taraftan daralttığı çubuklar arasındaki yükseklik farkını kullanarak ne kadar su birikebileceğini hesaplayan bir algoritmadır. Sanki saksıların arasına su dolduruyoruz da, sağdan soldan sızmasın diye çabalayan bir tesisatçı gibi çalışıyor. |
def jump(nums):
res = 0
l = r = 0
while r < len(nums) - 1:
farthest = 0
for i in range(l, r + 1):
farthest = max(farthest, i + nums[i])
l = r + 1
r = farthest
res += 1
return res | Greedy yaklaşımıyla listenin sonuna en az kaç zıplamayla ulaşılacağını hesaplar. İçinde sürekli "en uzağa nereden uçarım" diye plan yapan, bir sonraki hamlesini hayat memat meselesi haline getirmiş bir adamdır. |
def minPathSum(grid):
ROWS, COLS = len(grid), len(grid[0])
res = [[float('inf')] * (COLS + 1) for _ in range(ROWS + 1)]
res[ROWS - 1][COLS] = 0
for r in range(ROWS - 1, -1, -1):
for c in range(COLS - 1, -1, -1):
res[r][c] = grid[r][c] + min(res[r + 1][c], res[r][c + 1])
return re... | Grid üzerindeki her hücreye ulaşmak için gereken en küçük toplam maliyeti dinamik programlama ile hesaplayan, sabırlı bir abimizdir. Matriste sağa mı aşağı mı gitsem diye ağlayıp duran geliştiriciler için rotayı önceden çizen tam bir rota rehberidir. |
def uniquePaths(m, n):
row = [1] * n
for i in range(m - 1):
newRow = [1] * n
for j in range(n - 2, -1, -1):
newRow[j] = newRow[j + 1] + row[j]
row = newRow
return row[0] | m x n boyutundaki bir ızgarada, başlangıçtan bitişe kaç farklı yolla gidilebileceğini dinamik programlama ile hesaplayan bir fonksiyondur. Kendi kendine "bana labirent demeyin, ben aslında bir matematikçiyim" diye hava atan, biraz karmaşık ama işini bilen bir arkadaştır. |
def uniquePathsWithObstacles(obstacleGrid):
M, N = len(obstacleGrid), len(obstacleGrid[0])
dp = [0] * N
dp[N-1] = 1
for r in reversed(range(M)):
for c in reversed(range(N)):
if obstacleGrid[r][c]:
dp[c] = 0
elif c + 1 < N:
dp[c] = dp[c] + d... | Bu fonksiyon, içinde engeller bulunan bir ızgarada başlangıçtan bitişe kaç farklı yolla gidilebileceğini dinamik programlama ile hesaplar. Yolda bir taşa çarpmak kadar sinir bozucu olan engelleri görünce oradan geçiş yolunu sıfırlayan, sanki labirentte değil de mayın tarlasında yürüyormuşsunuz gibi çalışan bir arkadaş. |
def minDistance(word1, word2):
cache = [[float('inf')] * (len(word2) + 1) for _ in range(len(word1) + 1)]
for j in range(len(word2) + 1): cache[len(word1)][j] = len(word2) - j
for i in range(len(word1) + 1): cache[i][len(word2)] = len(word1) - i
for i in range(len(word1) - 1, -1, -1):
for j in r... | Edit distance veya Levenshtein mesafesi olarak bilinen bu algoritma, iki metni birbirine benzetmek için gereken minimum ekleme, silme veya değiştirme hamlesini hesaplar. Sanki elinde çok kirli bir çamaşır sepeti varmış da onları kusursuz düzenli hale getirmek için kaç hamle yapman gerektiğini bulan bir takıntı nöbeti g... |
def minWindow(s, t):
if t == "": return ""
countT, window = {}, {}
for c in t: countT[c] = 1 + countT.get(c, 0)
have, need = 0, len(countT)
res, resLen = [-1, -1], float('inf')
l = 0
for r in range(len(s)):
c = s[r]
window[c] = 1 + window.get(c, 0)
if c in countT and ... | Sliding window yöntemini kullanarak, t stringindeki tüm karakterleri içeren en kısa alt diziyi s'in içinde avlayan fonksiyon. İşine gelmeyeni pencereden dışarı atan, bulduğu en küçük parçayı ise kendine saklayan tam bir fırsatçı. |
def validPalindrome(s):
l, r = 0, len(s) - 1
while l < r:
if s[l] != s[r]:
skipL, skipR = s[l + 1:r + 1], s[l:r]
return (skipL == skipL[::-1] or skipR == skipR[::-1])
l, r = l + 1, r - 1
return True | Bir karakteri silerek metnin palindrom olup olmadığını kontrol eden bu fonksiyon, iki uçtan birbirine yaklaşırken arıza çıkaran karakteri görünce ya soldan ya sağdan birini harcıyor. İlişkilerdeki "birimiz eksik olsa da olur" mantığıyla çalışan, hata payını affeden ilginç bir arkadaş kendisi. |
def findDuplicates(nums):
res = []
for n in nums:
n = abs(n)
if nums[n - 1] < 0:
res.append(n)
nums[n - 1] = -nums[n - 1]
return res | Dizideki sayıları indeks olarak kullanıp, önceden ziyaret edilenleri negatif yaparak mükerrer olanları bulan bir yöntem. Sayıları kendi içinde işaretleyerek hafıza kazanan ama listenin kimyasını da bozan ilginç bir arkadaş kendisi. |
def rotate(nums, k):
k = k % len(nums)
l, r = 0, len(nums) - 1
while l < r:
nums[l], nums[r] = nums[r], nums[l]
l, r = l + 1, r - 1
l, r = 0, k - 1
while l < r:
nums[l], nums[r] = nums[r], nums[l]
l, r = l + 1, r - 1
l, r = k, len(nums) - 1
while l < r:
... | Bu fonksiyon, bir listeyi belirli bir k adım kadar sağa kaydırmak için elemanların yerini üç aşamalı ters çevirme yöntemiyle değiştirir. Listeyi sürekli döndürüp duran, yer beğenmeyen kararsız bir misafir gibi davranıyor resmen. |
def exist(board, word):
ROWS, COLS = len(board), len(board[0])
path = set()
def dfs(r, c, i):
if i == len(word): return True
if (r < 0 or c < 0 or r >= ROWS or c >= COLS or word[i] != board[r][c] or (r, c) in path): return False
path.add((r, c))
res = (dfs(r + 1, c, i + 1) or... | DFS kullanarak harf matrisi üzerinde aranan kelimeyi bulan, Backtracking yöntemiyle yanlış yola girince geri dönen inatçı bir fonksiyon. Adeta labirentte kaybolup her köşeyi tek tek kontrol eden ama yine de sonunda yolu bulan bir kaşif gibi çalışıyor. |
def longestConsecutive(nums):
numSet = set(nums)
longest = 0
for n in numSet:
if (n - 1) not in numSet:
length = 0
while (n + length) in numSet:
length += 1
longest = max(length, longest)
return longest | Dizideki sayıları kümeye çevirip ardışık sayı dizilerinin uzunluğunu hesaplayan ve en uzun olanı bulan bir fonksiyon. Sayıların birbirine komşuluk teklifini reddettiği bir dünyada, kimin en uzun zinciri kurduğunu bulmaya çalışan bir dedektif gibi çalışıyor. |
def intersection(nums1, nums2):
set1 = set(nums1)
set2 = set(nums2)
return list(set1 & set2) | İki listeyi kümelere dönüştürüp ortak elemanlarını bulan, yani kısaca kimlerin arkadaş çevresinde ortak tanıdığı var diye fişleyen bir fonksiyon. İnsan kaynakları departmanı gibi çalışan bu kod, ortak olmayanları anında kapı dışarı ediyor. |
def addStrings(num1, num2):
res = []
carry = 0
p1, p2 = len(num1) - 1, len(num2) - 1
while p1 >= 0 or p2 >= 0 or carry:
x1 = int(num1[p1]) if p1 >= 0 else 0
x2 = int(num2[p2]) if p2 >= 0 else 0
value = (x1 + x2 + carry) % 10
carry = (x1 + x2 + carry) // 10
res.app... | İki büyük sayıyı string olarak alıp, tıpkı ilkokulda alt alta toplama yapar gibi elde var bir mantığıyla toplayan bir fonksiyondur. Sayıları rakam rakam işleyip taşıma işlemini hallediyor, yani kısacası bilgisayara ilkokul matematiğini zorla öğretiyoruz. |
def addBinary(a, b):
res = ""
carry = 0
a, b = a[::-1], b[::-1]
for i in range(max(len(a), len(b))):
digitA = int(a[i]) if i < len(a) else 0
digitB = int(b[i]) if i < len(b) else 0
total = digitA + digitB + carry
char = str(total % 2)
res = char + res
carr... | İki binary string sayıyı basamak basamak toplayıp elde var bir durumunu takip ederek sonuç dönen fonksiyondur. Sanki ilkokulda alt alta toplama yapıyormuşuz gibi davranıp, bilgisayarın dilinde 0 ve 1'lerle oynamaktan keyif alan garip bir algoritma kendisi. |
def multiply(num1, num2):
if "0" in [num1, num2]: return "0"
res = [0] * (len(num1) + len(num2))
num1, num2 = num1[::-1], num2[::-1]
for i1 in range(len(num1)):
for i2 in range(len(num2)):
digit = int(num1[i1]) * int(num2[i2])
res[i1 + i2] += digit
res[i1 + i2... | İki büyük sayıyı karakter dizisi olarak alıp çarpma işlemini ilkokul usulü basamak basamak yapan algoritma. Çarpmayı unutanlar için, sanki elde var birleri kendisi hesaplıyormuş gibi triplere giren fazla çalışkan bir arkadaşımız. |
def myPow(x, n):
def helper(x, n):
if x == 0: return 0
if n == 0: return 1
res = helper(x, n // 2)
res = res * res
return x * res if n % 2 else res
res = helper(x, abs(n))
return res if n >= 0 else 1 / res | X sayısının n'inci kuvvetini binary exponentiation yöntemiyle hesaplayan, işlem yükünü azaltmak için sürekli kendini ikiye bölen verimli bir fonksiyon. Sanki çok zor bir iş yapıyormuş gibi n'i sürekli yarısı kadar işe zorlayıp sonunda üssü alıyor, tam bir ekip çalışması örneği. |
def isPerfectSquare(num):
l, r = 1, num
while l <= r:
mid = (l + r) // 2
if mid * mid > num: r = mid - 1
elif mid * mid < num: l = mid + 1
else: return True
return False | Binary search algoritmasını kullanarak bir sayının tam kare olup olmadığını kontrol eder. Sayıyı ikiye bölüp durmadan arayarak, kendini karesiyle eşleştirmeye çalışan, bulamazsa da "ben yoruldum hayat" diyerek pes eden kardeşimizdir kendisi. |
def generate(numRows):
res = [[1]]
for i in range(numRows - 1):
temp = [0] + res[-1] + [0]
row = []
for j in range(len(res[-1]) + 1):
row.append(temp[j] + temp[j + 1])
res.append(row)
return res | Pascal üçgeni oluşturmak için her satırdaki komşu sayıları toplayıp yeni bir liste döner. İnsanlar bunu el çabukluğuyla kağıda çizerken bizimki bilgisayarın başında, "acaba hangi sayıyı nereye toplasam" diye saatlerce uğraşıyor, biraz fazla mesai yapıyor yani. |
def getRow(rowIndex):
res = [1]
for i in range(rowIndex):
next_row = [0] * (len(res) + 1)
for j in range(len(res)):
next_row[j] += res[j]
next_row[j + 1] += res[j]
res = next_row
return res | Pascal üçgenindeki ilgili satırı iteratif bir şekilde inşa ederek döndüren bir fonksiyondur. Alt alta toplama yapmaktan yorulan Pascal amcanın işini elinden alıp tüm hesap yükünü tek başına sırtlanan, azimli bir yazılım parçasıdır. |
def minimumTotal(triangle):
dp = triangle[-1]
for row in range(len(triangle) - 2, -1, -1):
for i in range(len(triangle[row])):
dp[i] = triangle[row][i] + min(dp[i], dp[i + 1])
return dp[0] | Üçgen yapısındaki sayıların toplamını, alttan yukarı doğru dinamik programlama ile en küçük olacak şekilde hesaplayan bir algoritmadır. Sanki kendi bütçesini yönetemeyen bir öğrenci gibi, her basamakta en ucuz yolu seçip yukarı tırmanan çok hesaplı bir fonksiyon. |
def rob3(root):
def dfs(root):
if not root: return [0, 0]
leftPair = dfs(root.left)
rightPair = dfs(root.right)
withRoot = root.val + leftPair[1] + rightPair[1]
withoutRoot = max(leftPair) + max(rightPair)
return [withRoot, withoutRoot]
return max(dfs(root)) | Ağaç yapısındaki düğümleri, komşu olanları seçmemek şartıyla en yüksek toplamı verecek şekilde seçen dinamik programlama yaklaşımıdır. Kökü alırsam çocuklara el sürmem diyen, kuralcı ama kârlı bir soygun planı gibi düşünebilirsin. |
def pathSum(root, targetSum):
res = []
def dfs(node, path, currSum):
if not node: return
path.append(node.val)
currSum += node.val
if not node.left and not node.right and currSum == targetSum:
res.append(list(path))
dfs(node.left, path, currSum)
dfs(no... | Ağaç yapısındaki tüm yolları derinlemesine (DFS) gezerek, değerleri toplamı hedef sayıya eşit olan yaprakları bulan bir fonksiyondur. Kökten yaprağa kadar izini sürüp toplam tutturmaya çalışan bu kod, doğru yolu bulamazsa başladığı yere geri dönen kararsız bir gezgin gibidir. |
def maxProduct(nums):
res = max(nums)
curMin, curMax = 1, 1
for n in nums:
if n == 0:
curMin, curMax = 1, 1
continue
tmp = curMax * n
curMax = max(n * curMax, n * curMin, n)
curMin = min(tmp, n * curMin, n)
res = max(res, curMax)
return res | Dizi içerisindeki ardışık elemanların çarpımından elde edilebilecek en yüksek değeri bulan, Kadane algoritmasının biraz daha hırslı bir türevidir. İçerideki sayılarla sürekli çarpım yarıştırıp negatiflerle bile başa çıkmaya çalışan, sanki borsa takip ediyor gibi stresli bir fonksiyon. |
def decodeString(s):
stack = []
for i in range(len(s)):
if s[i] != ']':
stack.append(s[i])
else:
substr = ""
while stack[-1] != '[':
substr = stack.pop() + substr
stack.pop()
k = ""
while stack and stack[-1].... | İç içe geçmiş parantezli yapıları ve sayıları kullanarak şifrelenmiş metni çözen yığın tabanlı bir algoritma. Kod sanki labirentte kaybolmuş birinin yolunu bulmaya çalışması gibi, parantezleri gördüğü an 'burada bir işler dönüyor' diyerek içindekileri çarparak genişletiyor. |
class Codec:
def serialize(self, root):
res = []
def dfs(node):
if not node:
res.append("N")
return
res.append(str(node.val))
dfs(node.left)
dfs(node.right)
dfs(root)
return ",".join(res)
def deserial... | Ağaç yapısındaki verileri virgüllerle ayrılmış bir metne çeviren ve sonra tekrar eski haline döndüren, kısaca veriyi paketleyip açan bir kargo şirketi gibi çalışan fonksiyonlar. Sanki elimizde çok değerli bir eşya varmış da onu kutulayıp geri açarken hiç hasar vermemeye çalışıyormuşuz gibi davranıyorlar. |
def zigzagLevelOrder(root):
res = []
q = collections.deque([root] if root else [])
even_level = False
while q:
level = []
for _ in range(len(q)):
node = q.popleft()
level.append(node.val)
if node.left: q.append(node.left)
if node.right: q.a... | Ağaç yapısındaki düğümleri her seviyede yön değiştirerek, yani zikzak çizecek şekilde sırayla listeler. Bir sağa bir sola yalpalamaktan yolu şaşırmış gibi görünse de aslında her seviyede yön değiştirerek düğümleri listeye ekleyen garip bir yapı. |
def maxPathSum(root):
res = [root.val]
def dfs(root):
if not root: return 0
leftMax = max(dfs(root.left), 0)
rightMax = max(dfs(root.right), 0)
res[0] = max(res[0], root.val + leftMax + rightMax)
return root.val + max(leftMax, rightMax)
dfs(root)
return res[0] | Ağaç yapısındaki düğümler arasında değerleri toplamı en büyük olan yolu bulan, DFS algoritması kullanan bir fonksiyon. Tüm dalları tek tek gezip "en çok puanı nerede toplarım" diye hesap kitap yapan, biraz paragöz ama iş bitirici bir arkadaşımız. |
def flatten(root):
def dfs(root):
if not root: return None
leftTail = dfs(root.left)
rightTail = dfs(root.right)
if root.left:
leftTail.next = root.right
root.right = root.left
root.left = None
return rightTail or leftTail or root
dfs(r... | Ağaç yapısındaki veriyi, dalları sadece sağa doğru uzanan tek bir düz liste gibi birleştiren bir derinlik öncelikli arama algoritmasıdır. Ağacı sanki saç tarar gibi dümdüz eden, düğümleri sağ koluna yapıştırıp sola olanları da öksüz bırakan bir hırsız gibi çalışıyor. |
def connect(root):
cur, nxt = root, root.left if root else None
while cur and nxt:
cur.left.next = cur.right
if cur.next:
cur.right.next = cur.next.left
cur = cur.next
if not cur:
cur = nxt
nxt = cur.left
return root | Bu fonksiyon, ağaç yapısındaki düğümleri aynı seviyede birbirine bağlayarak yatay bir hat oluşturur. Yani düğümlere "yanındakine selam ver" diyor, yoksa da alt kata inip komşuluk bağlarını kurmaya devam ediyor. |
import heapq
def kthSmallest(matrix, k):
res = []
for r in range(len(matrix)):
for c in range(len(matrix[0])):
res.append(matrix[r][c])
heapq.heapify(res)
for _ in range(k - 1):
heapq.heappop(res)
return res[0] | Matristeki tüm elemanları düz bir listeye toplayıp yığın (heap) yapısına dönüştürerek, k. sıradaki en küçük sayıyı döndüren fonksiyondur. Elindeki listeyi güzelce dizip en küçüğü bulmak yerine tüm mahalleyi toplayıp bir de yığınla uğraşmak, biraz işi yokuşa sürmek değil mi? |
class MedianFinder:
def __init__(self):
self.small, self.large = [], []
def addNum(self, num):
heapq.heappush(self.small, -1 * num)
if self.small and self.large and (-1 * self.small[0]) > self.large[0]:
val = -1 * heapq.heappop(self.small)
heapq.heappush(self.larg... | İki heap kullanarak sayıları dengede tutan ve her an ortadaki değeri şak diye bulan fonksiyonlar bütünü. Sayıları küçükler ve büyükler diye iki tarafa ayırıp sürekli birbirleriyle kavga ettirerek ortancayı bulmaya çalışan tam bir denge hastası. |
import collections
def maxSlidingWindow(nums, k):
output = []
q = collections.deque()
l = r = 0
while r < len(nums):
while q and nums[q[-1]] < nums[r]:
q.pop()
q.append(r)
if l > q[0]:
q.popleft()
if (r + 1) >= k:
output.append(nums[q[0... | Dizi üzerinde k boyutlu bir pencereyi kaydırarak her aralıktaki en büyük elemanı bulan klasik bir algoritmadır. Kendi içinde sürekli ayıklama yapan bu fonksiyon, gereksiz sayıları çöpe atarak listede sürekli zirveye oynayanları takip eden bir işsiz gibi çalışıyor. |
def canFinish(numCourses, prerequisites):
preMap = {i: [] for i in range(numCourses)}
for crs, pre in prerequisites:
preMap[crs].append(pre)
visitSet = set()
def dfs(crs):
if crs in visitSet: return False
if preMap[crs] == []: return True
visitSet.add(crs)
for pre... | Dersleri bitirebilmek için aradaki ön koşul döngülerini kontrol eden bu fonksiyon, Topolojik Sıralama mantığını kullanarak graf üzerinde bir çıkmaz sokak olup olmadığını denetliyor. Mezun olmaya çalışan öğrencinin ders programındaki "önce bunu al, sonra şunu al" karmaşasını çözmeye çalışırken kendi kuyruğunu kovalayan ... |
def findCircleNum(isConnected):
N = len(isConnected)
visited = set()
def dfs(i):
for j in range(N):
if isConnected[i][j] == 1 and j not in visited:
visited.add(j)
dfs(j)
provinces = 0
for i in range(N):
if i not in visited:
visi... | Bağlantı matrisini kullanarak birbiriyle dolaylı veya doğrudan ilişkili olan şehir gruplarını, yani toplam eyalet sayısını DFS algoritması ile bulur. Birbirini tanıyan herkesi aynı kümeye toplayıp, henüz kimseyle tanışmamış yalnızları tek tek gezen tam bir sosyalleşme uzmanı kendisi. |
def findRedundantConnection(edges):
par = [i for i in range(len(edges) + 1)]
rank = [1] * (len(edges) + 1)
def find(n):
p = par[n]
while p != par[p]:
par[p] = par[par[p]]
p = par[p]
return p
def union(n1, n2):
p1, p2 = find(n1), find(n2)
if... | Disjoint Set Union yapısını kullanarak graf içindeki gereksiz bağlantıyı tespit eden bir algoritmadır. Birbirine zaten bağlı olan iki düğümü tekrar bağlamaya kalkan o "gereksiz" kenarı bulup, düğün bozmaya çalışan hayırlı bir evlat gibi hemen ifşa ediyor. |
import collections
def ladderLength(beginWord, endWord, wordList):
if endWord not in wordList: return 0
nei = collections.defaultdict(list)
wordList.append(beginWord)
for word in wordList:
for j in range(len(word)):
pattern = word[:j] + "*" + word[j + 1:]
nei[pattern].app... | Kelime kelime harf değiştirerek bir kelimeden diğerine ulaşmak için BFS algoritmasını kullanan, kelime dağarcığını bir oyun parkına çeviren fonksiyon. Hedefe ulaşamazsan "yol yok" diye suratına bakıyor, ulaşınca da kaç adımda gittiğini sayıp eline veriyor. |
def minSubArrayLen(target, nums):
l, total = 0, 0
res = float('inf')
for r in range(len(nums)):
total += nums[r]
while total >= target:
res = min(r - l + 1, res)
total -= nums[l]
l += 1
return 0 if res == float('inf') else res | İki işaretçi kullanarak toplamı hedef değere eşit veya büyük olan en kısa alt dizinin uzunluğunu bulur. Sliding window tekniğiyle çalışan bu arkadaş, bulamayınca da 0 dönüp durumu kurtarıyor. |
def findMin2(nums):
l, r = 0, len(nums) - 1
while l < r:
mid = l + (r - l) // 2
if nums[mid] > nums[r]:
l = mid + 1
elif nums[mid] < nums[r]:
r = mid
else:
r -= 1
return nums[l] | Binary search algoritmasını kullanarak sıralı ama döndürülmüş bir listedeki en küçük sayıyı bulur. Listeyi sürekli ortadan ikiye bölerek ilerleyen bu fonksiyon, aradığı küçük sayıyı bulana kadar kendi dünyasında dönüp duruyor. |
class Node:
def __init__(self, key, val):
self.key, self.val = key, val
self.prev = self.next = None
class LRUCache:
def __init__(self, capacity):
self.cap = capacity
self.cache = {}
self.left, self.right = Node(0, 0), Node(0, 0)
self.left.next, self.right.prev =... | LRU Cache; kapasitesi dolduğunda en az kullanılan veriyi çöpe atan, çift yönlü bağlı liste ve sözlük kullanan bir yapı. Bellekteki o eski ve modası geçmiş elemanları, sanki hiç yaşanmamış gibi nazikçe kapının önüne koyan vicdansız bir hafıza yöneticisi. |
import collections, heapq
def leastInterval(tasks, n):
count = collections.Counter(tasks)
maxHeap = [-cnt for cnt in count.values()]
heapq.heapify(maxHeap)
time = 0
q = collections.deque()
while maxHeap or q:
time += 1
if maxHeap:
cnt = 1 + heapq.heappop(maxHeap)
... | Görevlerin arasına n süresi kadar boşluk koyarak toplam çalışma süresini hesaplayan bir çizelgeci gibi davranır. En sık yapılan işi önceliklendiren bir heap yapısı kullanıyor, yani işleri sıraya koyma konusunda benden daha düzenli çalıştığı kesin. |
def subarraySum(nums, k):
res = 0
curSum = 0
prefixSums = {0: 1}
for n in nums:
curSum += n
diff = curSum - k
res += prefixSums.get(diff, 0)
prefixSums[curSum] = 1 + prefixSums.get(curSum, 0)
return res | Hash map kullanarak bir dizideki toplamı k olan alt dizilerin sayısını bulan, zaman karmaşıklığını O(n) seviyesine çeken etkili bir algoritmadır. Sanki kütüphane fişi toplar gibi, o ana kadar elde edilen toplamların kaç kere karşısına çıktığını sayıp bizi gereksiz iç içe döngülerden kurtaran bir hayat kurtarıcıdır. |
def longestPalindromeSubseq(s):
dp = [[0] * len(s) for _ in range(len(s))]
for i in range(len(s) - 1, -1, -1):
dp[i][i] = 1
for j in range(i + 1, len(s)):
if s[i] == s[j]:
dp[i][j] = 2 + dp[i + 1][j - 1]
else:
dp[i][j] = max(dp[i + 1][j], d... | Dinamik programlama kullanarak bir metin içindeki en uzun palindromik alt dizinin uzunluğunu hesaplar. Kendine has simetrisini koruyan parçaları bulmak için matris üzerinde dönüp duran, bulmacayı çözdükten sonra da "hadi eyvallah" diyen yorucu bir fonksiyon. |
def search2(nums, target):
l, r = 0, len(nums) - 1
while l <= r:
m = l + (r - l) // 2
if nums[m] == target: return True
if nums[l] == nums[m] and nums[m] == nums[r]:
l += 1; r -= 1; continue
if nums[l] <= nums[m]:
if nums[l] <= target < nums[m]: r = m - 1
... | Binary search mantığını kullanarak dönen bir dizideki elemanı arar; ancak tekrar eden sayılar yüzünden kafası karışınca kenarları daraltarak ilerler. Kendi kendine dertlenen bu fonksiyon, aradığını bulamazsa "benim suçum yok, liste sorunlu" diyerek False döner. |
def canCompleteCircuit(gas, cost):
if sum(gas) < sum(cost): return -1
total = 0
res = 0
for i in range(len(gas)):
total += (gas[i] - cost[i])
if total < 0:
total = 0
res = i + 1
return res | Benzin ve maliyet listelerini karşılaştırarak arabanın rotayı tamamlayıp tamamlayamayacağını kontrol eder. Depoyu dolduramadığımız noktada umudu kesip bir sonraki istasyondan şansımızı deniyoruz, sanki hayatın kendisi gibi. |
def checkSubarraySum(nums, k):
remainder = {0: -1}
total = 0
for i, n in enumerate(nums):
total += n
r = total % k
if r not in remainder:
remainder[r] = i
elif i - remainder[r] > 1:
return True
return False | Bir listenin toplamının k sayısına tam bölündüğü en az iki elemanlı bir alt dizi olup olmadığını kontrol eder. Sayıların toplamından kalanları hafızada tutarak, aynı kalanı daha önce gördü mü diye kontrol eden tam bir dedektif gibi çalışan fonksiyon. |
def fib(n):
if n <= 1: return n
return fib(n-1) + fib(n-2) | Kendini sürekli tekrar eden özyinelemeli yapısıyla Fibonacci dizisindeki n. sayıyı hesaplar. Kendi içine sürekli "kardeş, sen benden bir eksik ve iki eksik olanı bul getir" diyerek, işlemciyi gereksiz yere terleten tam bir baş belası. |
def maxSubArray(nums):
max_sum, cur_sum = float('-inf'), 0
for n in nums:
cur_sum = max(cur_sum + n, n)
max_sum = max(max_sum, cur_sum)
return max_sum | Kadane's algorithm kullanarak dizideki bitişik elemanların toplamından en büyüğünü bulan, verimli olduğu kadar da kafası karışık bir fonksiyondur. Kendi kendine sürekli "şuradan devam mı etsem yoksa sil baştan mı başlasam" diye didinip duran, kararsız bir yapıya sahip. |
def bubbleSort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j] | Elemanları sürekli birbiriyle kıyaslayıp büyük olanı sona iterek sıralayan, yavaşlığıyla meşhur Bubble Sort algoritmasıdır. Sanki büyük sayıları ağır yükmüş gibi en sona taşıyarak listeyi sıralıyor, tam bir hamal işi. |
def binarySearch(arr, target):
l, r = 0, len(arr)-1
while l <= r:
mid = (l + r) // 2
if arr[mid] == target: return mid
elif arr[mid] < target: l = mid + 1
else: r = mid - 1
return -1 | Sıralı bir dizide hedef elemanı ararken sürekli yarıya bölüp alanı daraltan Binary Search algoritmasıdır. Sanki sözlükte kelime arıyormuş gibi davranıp, hedefi bulamazsa -1 dönerek "kardeşim bu bende yok" diyen dürüst bir fonksiyondur. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.