code stringlengths 35 1.46k | explanation stringlengths 152 368 |
|---|---|
def isUniqueCharacters(s):
seen = set()
for ch in s:
if ch in seen:
return False
seen.add(ch)
return True | String içindeki karakterlerin benzersiz olup olmadığını bir küme yapısı kullanarak denetleyen fonksiyon. Eğer bir karakteri ikinci kez görüyorsa 'yine mi sen' diyerek hemen False döndürüp topukluyor. |
def checkPermutationOfString(s1, s2):
return sorted(s1) == sorted(s2) | Verilen iki metni harf sırasına dizip birbirinin aynısı olup olmadıklarını kontrol eden bir fonksiyon. Yani iki metin aynı harflerden oluşuyorsa, 'biz aslında aynı kişiyiz' deyip True döndürüyor. |
def compressStringIfShorter(s):
if not s:
return s
result = []
count = 1
for i in range(1, len(s)):
if s[i] == s[i - 1]:
count += 1
else:
result.append(s[i - 1] + str(count))
count = 1
result.append(s[-1] + str(count))
compressed = "".j... | Bu fonksiyon, birbirinin aynısı olan karakterleri sayıp yanına ekleyerek stringi kısaltmaya çalışır. Eğer sonuç orijinalinden daha uzun çıkarsa 'yok ben almayayım' deyip ilk halini geri gönderen, oldukça seçici bir algoritma. |
def isOneEditDistanceApart(s1, s2):
if abs(len(s1) - len(s2)) > 1:
return False
if len(s1) > len(s2):
s1, s2 = s2, s1
for i in range(len(s1)):
if s1[i] != s2[i]:
if len(s1) == len(s2):
return s1[i + 1:] == s2[i + 1:]
return s1[i:] == s2[i + 1:]... | Bu fonksiyon, iki string arasında en fazla bir karakterlik ekleme, silme veya değiştirme farkı olup olmadığını kontrol eder. Eğer stringler arasındaki fark bir 'bir düzeltme' mesafesinden fazlaysa, o iş yaş kardeşim, direkt False döner. |
def findAllAnagramsInString(s, p):
from collections import Counter
if len(p) > len(s):
return []
p_count = Counter(p)
window = Counter(s[:len(p)])
result = []
if window == p_count:
result.append(0)
for i in range(len(p), len(s)):
window[s[i]] += 1
left_char = ... | Sliding window algoritmasını kullanarak ana metin içinde hedef kelimenin tüm anagramlarını bulan bir fonksiyon. Sen karakterleri sayıp sağdan ekleyip soldan çıkararak ilerle, o seni metin içinde kaybolmaktan kurtarır yoksa bu işin içinden çıkamazsın. |
def excelColumnTitle(n):
result = []
while n > 0:
n -= 1
result.append(chr(n % 26 + ord("A")))
n //= 26
return "".join(reversed(result)) | Bu fonksiyon, 1'den başlayan sayısal sütun değerlerini Excel'in meşhur A, B, Z, AA şeklindeki harf kombinasyonlarına dönüştürür. '1'e A diyeyim, 27'ye gelince başım ağrımasın' diye dertlenen Excel'in kendi kendine yarattığı sayı sistemini çözmeye çalışan bir yapı. |
def countPrimesBelowN(n):
if n < 2:
return 0
is_prime = [True] * n
is_prime[0] = is_prime[1] = False
for i in range(2, int(n ** 0.5) + 1):
if is_prime[i]:
for j in range(i * i, n, i):
is_prime[j] = False
return sum(is_prime) | Eratosten Kalburu algoritmasını kullanarak n sayısına kadar olan tüm asal sayıları sayar. Liste üzerinde sürekli eleme yaparak asal olmayanları ayıklayan, sanki elinde elek varmış gibi çalışan temizlikçi fonksiyon. |
def thirdMaximumNumber(nums):
top3 = []
for num in nums:
if num not in top3:
top3.append(num)
top3.sort(reverse=True)
if len(top3) > 3:
top3.pop()
return top3[2] if len(top3) == 3 else max(top3) | Bu fonksiyon, verilen listedeki benzersiz sayıları küçük bir sepete alıp sıralayarak üçüncü en büyük değeri bulur. Listede yeterince sayı yoksa en büyüğünü dönüp 'bu kadar yettiyse demek ki en kralı bu' diyerek durumu kurtarır. |
def arrayPairSumOptimal(nums):
nums.sort()
return sum(nums[::2]) | Diziyi sıralayıp çift indisli elemanları toplayarak olası en büyük ikili toplam çiftini elde eder. Listeyi küçükten büyüğe dizip birbirini yememeleri için komşu yapan, biraz çapkın bir mantığı var. |
def canPlaceFlowers(flowerbed, n):
count = 0
length = len(flowerbed)
for i in range(length):
if flowerbed[i] == 0:
prev_empty = (i == 0) or (flowerbed[i - 1] == 0)
next_empty = (i == length - 1) or (flowerbed[i + 1] == 0)
if prev_empty and next_empty:
... | Bu fonksiyon, çiçek tarhındaki boşluklara komşularını rahatsız etmeden çiçek ekip ekemeyeceğinizi kontrol eder. Çiçeklerin dibine boşluk bırakmadan dikim yapmaya çalışırsanız, bu sistem sizi nazikçe reddedip bahçıvanlıktan emekli eder. |
def findAllMissingNumbersInRange(nums):
n = len(nums)
present = set(nums)
return [i for i in range(1, n + 1) if i not in present] | 1'den n'e kadar olan sayılar arasında listede bulunmayanları bulan bir fonksiyon. Sanki yoklama alıyor da kim derse gelmemiş diye tek tek parmak kaldırıyor, işi gücü yok listenin açığını arıyor. |
def isToeplitzMatrix(matrix):
rows, cols = len(matrix), len(matrix[0])
for r in range(rows - 1):
for c in range(cols - 1):
if matrix[r][c] != matrix[r + 1][c + 1]:
return False
return True | Matrisin köşegenlerindeki tüm elemanların birbirine eşit olup olmadığını kontrol eden, çapraz komşularla köşe kapmaca oynayan bir algoritma. Eğer matrisin köşegeni bozuksa, bu fonksiyon hemen 'burada bir işler dönüyor' deyip False bayrağını çekiyor. |
def dayOfYearCalculation(date_str):
from datetime import date
year, month, day = map(int, date_str.split("-"))
return (date(year, month, day) - date(year, 1, 1)).days + 1 | Verilen tarihi yılın kaçıncı günü olduğunu hesaplamak için yılbaşından itibaren kaç gün geçtiğini bulan bir fonksiyon. Sanki o günün yılın kaçıncı günü olduğunu bilince dünya çok değişecekmiş gibi uğraşıp duruyor işte. |
def maxConsecutiveOnes(nums):
max_count = current = 0
for num in nums:
if num == 1:
current += 1
max_count = max(max_count, current)
else:
current = 0
return max_count | Bu fonksiyon bir listedeki ardışık 1'lerin en uzun serisini bulur. Liste içinde sanki bir oyun oynuyor, 0'ı görünce 'aa yandı oyun' deyip sayacı sıfırlıyor. |
def relativeSortArray(arr1, arr2):
order = {val: i for i, val in enumerate(arr2)}
in_order = sorted([x for x in arr1 if x in order], key=lambda x: order[x])
remaining = sorted([x for x in arr1 if x not in order])
return in_order + remaining | Bu fonksiyon, arr1 listesindeki elemanları arr2 listesindeki sıralamaya göre dizer, kalanları da sona ekler. Sanki bir sınıftaki öğrencileri boy sırasına dizmeye çalışırken, en öne torpillileri alan, kalan küçük Emrahlar'ıda da arkaya sayısal sıralamayla dizen bir öğretmen gibi davranıyor. |
def treeDiameterLongestPath(root):
diameter = [0]
def depth(node):
if not node:
return 0
left = depth(node.left)
right = depth(node.right)
diameter[0] = max(diameter[0], left + right)
return 1 + max(left, right)
depth(root)
return diameter[0] | Bu fonksiyon bir ağacın iki yaprağı arasındaki en uzun yolu, yani çapı hesaplar. Ağaçta dolanırken 'benim sağım mı daha derin solum mu' diye sürekli birbirini kıyaslayan, sanarsın kendi halinde bir dertleşme seansı. |
def flattenBinaryTreeToLinkedList(root):
current = root
while current:
if current.left:
rightmost = current.left
while rightmost.right:
rightmost = rightmost.right
rightmost.right = current.right
current.right = current.left
cur... | Bu fonksiyon, ağaç yapısındaki veriyi sol kolu tamamen koparıp sağa ekleyerek tek bir düz hat haline getiriyor. Kendi düğümlerini sağa yamalayıp solu boşaltan, işin sonunda ağaçlıktan çıkıp bildiğimiz listeye dönen bir fonksiyon bu. |
def sumAllRootToLeafPaths(root):
def dfs(node, current_number):
if not node:
return 0
current_number = current_number * 10 + node.value
if not node.left and not node.right:
return current_number
return dfs(node.left, current_number) + dfs(node.right, current_n... | Ağaç yapısındaki kökten yaprağa giden yolları sayısal değerlere dönüştürüp bunların toplamını hesaplayan bir algoritma. Sanki ağaçtaki her dal bir kredi kartı numarasıymış gibi rakamları yan yana dizip topluyor, varsayki hesap özetini çıkarıyor. |
def pathSumTotalCount(root, target):
def count_from(node, remaining):
if not node:
return 0
remaining -= node.value
total = 1 if remaining == 0 else 0
total += count_from(node.left, remaining)
total += count_from(node.right, remaining)
return total
if... | Bu fonksiyon, ağaç yapısındaki düğümlerin değerlerini toplayarak hedef sayıya ulaşan yolları sayan bir DFS algoritmasıdır. Kendini sürekli çağıra çağıra hedefi arayan, sanki evde kaybolan çorabını bütün evi altüst ederek arayan bir ev hanımı gibi çalışıyor. |
def buildTreeFromInorderPostorder(inorder, postorder):
class Node:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
if not inorder:
return None
root_value = postorder.pop()
root = Node(root_value)
mid = inorder.inde... | Bu fonksiyon, inorder ve postorder listelerini kullanarak ağacın düğümlerini yeniden inşa eder; resmen kayıp ilanı verilmiş verileri dedektif gibi birleştiriyor. Sağ ve sol alt ağaçları özyinelemeli olarak kurarken kök değerini postorder listesinin sonundan çeker, yani aslında ağacı tersten terzi gibi dikiyor. |
def binaryTreeRightSideView(root):
if not root:
return []
result = []
queue = [root]
while queue:
level_size = len(queue)
for i in range(level_size):
node = queue.pop(0)
if i == level_size - 1:
result.append(node.value)
if node.... | Ağacın sağ tarafındaki düğümleri toplayıp getiren, sanki bir binanın camından yan binaya bakan meraklı komşu gibi çalışan bir fonksiyon. Her seviyenin en sağındaki elemanı yakalayıp sonucu döndürerek, ağacın sağ profilini hatasız çıkarıyor. |
def countCompleteTreeNodes(root):
if not root:
return 0
return 1 + countCompleteTreeNodes(root.left) + countCompleteTreeNodes(root.right) | Verilen ağaç yapısındaki tüm düğümleri tek tek gezerek toplam sayıyı hesaplayan bir özyinelemeli fonksiyon. Kendi kendine dönüp duran bu arkadaş, adeta bitmeyen bir zincirleme toplantıda kimin nerede olduğunu saymaya çalışıyor. |
def convertBSTToDoublyLinkedList(root):
first = [None]
last = [None]
def inorder(node):
if not node:
return
inorder(node.left)
if last[0]:
last[0].right = node
node.left = last[0]
else:
first[0] = node
last[0] = node
... | Bu fonksiyon, ağaç yapısındaki düğümleri inorder yöntemiyle gezerek onları birbirine bağlar ve dairesel çift yönlü bir listeye dönüştürür. Ağacı bozup zincirleme işlere girişiyor, sanki çok huzurlu duran bir yapıyı zorla evrim geçirip liste yapmaya çalışan biraz hiperaktif bir yapı. |
def removeNthNodeFromEnd(head, n):
dummy = ListNodeSimple(0)
dummy.next = head
fast = slow = dummy
for _ in range(n):
fast = fast.next
while fast.next:
fast = fast.next
slow = slow.next
slow.next = slow.next.next
return dummy.next | Bu fonksiyon, tek bağlı bir listede sondan n. düğümü silmek için iki işaretçiyi aralarında n kadar mesafe bırakarak ilerletir. Sanki iki kişi arasında sürekli aynı mesafeyi korumaya çalışıp en son arkadakine çelme takan bir komedi filmine benziyor. |
def detectCycleStartInLinkedList(head):
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
pointer = head
while pointer != slow:
pointer = pointer.next
slow = slow.next
r... | Floyd'un döngü bulma algoritmasını kullanarak bağlı listenin içindeki o meşhur çemberin başladığı düğümü bulur. Kaplumbağa ve tavşan yarıştırıp tavşan yorulduğunda döngüyü yakalayan, kod dünyasının dedektiflik bürosu gibi çalışan bir arkadaş. |
def separateOddEvenListNodes(head):
if not head:
return head
odd = head
even = head.next
even_head = even
while even and even.next:
odd.next = even.next
odd = odd.next
even.next = odd.next
even = even.next
odd.next = even_head
return head | Bu fonksiyon, tek ve çift indisli düğümleri birbirine karıştırmadan gruplandıran klasik bir linked list düzenleme algoritmasıdır. Sanki düğümleri 'tekler sağa, çiftler sola' diye bağırarak birbirinden ayırmaya çalışan disiplinli bir öğretmen gibi davranıyor. |
def partitionListAroundValue(head, x):
before_head = ListNodeSimple(0)
after_head = ListNodeSimple(0)
before = before_head
after = after_head
while head:
if head.value < x:
before.next = head
before = before.next
else:
after.next = head
... | Bu fonksiyon, bağlı listeyi verilen x değerinden küçükler ve büyükler olarak iki takıma ayırıp birleştiriyor. Sanki sınıfta boy sırasına göre dizilmeye çalışıp sürekli birbirini dürtükleyen öğrencileri uslu uslu iki ayrı sıraya dizmek gibi bir şey. |
class RandomPointerListNode:
def __init__(self, value):
self.value = value
self.next = None
self.random = None
def copyListWithRandomPointer(head):
if not head:
return None
mapping = {}
node = head
while node:
mapping[node] = RandomPointerListNode(node.value... | Bu fonksiyon, hem bir sonraki düğüme hem de rastgele bir düğüme işaret eden karmaşık bir bağlı listeyi hafızadaki yerini koruyarak kopyalar. Sanki bir fotokopi makinesi bozulmuş da aynısının tıpkısını hafızasında tutmaya çalışıyor gibi, düğümleri sözlük yardımıyla eşleyerek birbirine bağlıyor. |
def mergeSortLinkedList(head):
if not head or not head.next:
return head
slow, fast = head, head.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
mid = slow.next
slow.next = None
left = mergeSortLinkedList(head)
right = mergeSortLinkedList(mid)
... | Bu fonksiyon bağlı listeyi ikiye bölüp sürekli özyinelemeli olarak sıralayan meşhur Merge Sort algoritmasını uygular. Listenin yarısını bulan o yavaş kaplumbağa ve hızlı tavşan ikilisi sonunda pes edip listeyi adam gibi sıraya diziyor. |
def reorderLinkedList(head):
if not head or not head.next:
return head
slow, fast = head, head.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
second = slow.next
slow.next = None
prev = None
while second:
next_node = second.next
s... | Linked listin ortasını bulup ikinci yarısını tersine çevirdikten sonra, iki parçayı fermuar gibi birbirine diker. Önce listeyi ikiye bölüp sonra birleştirerek düğümleri karıştıran, adeta bir puzzle parçalarını yanlış yerleştirip sonra düzelten kafası karışık bir mühendis gibi çalışıyor. |
def spiralMatrixGenerate(n):
matrix = [[0] * n for _ in range(n)]
top, bottom, left, right = 0, n - 1, 0, n - 1
num = 1
while top <= bottom and left <= right:
for c in range(left, right + 1):
matrix[top][c] = num
num += 1
top += 1
for r in range(top, botto... | n x n boyutunda bir matrisi, dışarıdan merkeze doğru sayıları spiral bir düzende doldurarak oluşturur. Sanki matrisin içinde hapsolmuş bir karınca varmış gibi sayıları köşelere çarptıra çarptıra dolanıp duruyor. |
def setMatrixZeroesInPlace(matrix):
rows, cols = len(matrix), len(matrix[0])
zero_rows, zero_cols = set(), set()
for r in range(rows):
for c in range(cols):
if matrix[r][c] == 0:
zero_rows.add(r)
zero_cols.add(c)
for r in range(rows):
for c in ... | Matriste sıfır gördüğü an o satır ve sütunu komple sıfırlayan bu fonksiyon, tam bir kaos sevdalısı. Eğer bir hücrede sıfır yakalarsa, o sıfırın tüm komşuluğunu tarumar edip ortamı karartıyor, resmen evin içine bir tane çürük elma girince tüm kasayı temizliyor. |
def searchSortedMatrixStaircase(matrix, target):
if not matrix:
return False
row, col = 0, len(matrix[0]) - 1
while row < len(matrix) and col >= 0:
if matrix[row][col] == target:
return True
elif matrix[row][col] > target:
col -= 1
else:
ro... | Satırları ve sütunları artan sırada düzenlenmiş matriste sağ üst köşeden başlayarak arama yapar. Mevcut değer hedeften büyükse sütun indeksini azaltır; küçükse satır indeksini artırır; eşitse True döndürür. |
def threeSumZero(nums):
nums.sort()
result = []
n = len(nums)
for i in range(n - 2):
if i > 0 and nums[i] == nums[i - 1]:
continue
left, right = i + 1, n - 1
while left < right:
total = nums[i] + nums[left] + nums[right]
if total < 0:
... | Bu fonksiyon listeden toplamı sıfır olan üçlü grupları avlar. Listenin önünü arkasını sıralayıp ikili işaretçi tekniğiyle, sanki bedava döner arayan üç arkadaş gibi birbirini tamamlayan sayıları bulup listeler. |
def fourSumTarget(nums, target):
nums.sort()
n = len(nums)
result = []
for i in range(n - 3):
if i > 0 and nums[i] == nums[i - 1]:
continue
for j in range(i + 1, n - 2):
if j > i + 1 and nums[j] == nums[j - 1]:
continue
left, right = j ... | Dörtlü toplamı hedef sayıya eşitleyen kombinasyonları bulmak için listeyi sıralayıp iç içe döngülerle avlanan bir algoritma. Kod o kadar çok geziniyor ki, sanki mahallede dört kişilik halı saha takımı kurmaya çalışan ama sürekli 'bu adamla daha önce oynadık' diyerek eleme yapan bir mahalle abisi gibi çalışıyor. |
def minimumRemoveToMakeValidParentheses(s):
s = list(s)
stack = []
for i, ch in enumerate(s):
if ch == "(":
stack.append(i)
elif ch == ")":
if stack:
stack.pop()
else:
s[i] = ""
for i in stack:
s[i] = ""
retu... | Bu fonksiyon, string içindeki parantezlerin dengesini bozan gereksiz karakterleri tespit edip onları siliyor. Kendi kendine parantez açıp kapatmayı unutan dağınık bir öğrencinin defterini toparlayan disiplinli bir öğretmen gibi çalışıyor. |
def decodeNestedString(s):
stack = []
current_str = ""
current_num = 0
for ch in s:
if ch.isdigit():
current_num = current_num * 10 + int(ch)
elif ch == "[":
stack.append((current_str, current_num))
current_str, current_num = "", 0
elif ch == "... | Bu fonksiyon, köşeli parantezler içindeki sayıları kullanarak metni belirtilen sayıda tekrarlayan karmaşık bir yapıyı çözer. İç içe geçmiş parantezlerle uğraşırken insanın beynini yakabilir, tam bir bilgisayar mühendisliği işkencesi. |
def basicCalculatorII(expression):
stack = []
num = 0
op = "+"
expression = expression.replace(" ", "") + "+"
for ch in expression:
if ch.isdigit():
num = num * 10 + int(ch)
else:
if op == "+":
stack.append(num)
elif op == "-":
... | Matematiksel bir ifadeyi işlem önceliğine göre çözen bu kod, çarpma ve bölmeyi toplama çıkarmadan önce halleder. İlkokul öğretmenimizin 'önce parantez içi, sonra çarpma bölme' diye kafamıza vura vura öğrettiği kuralları bir güzel uygulayan sistemin ta kendisi. |
def integerToEnglishWords(num):
if num == 0:
return "Zero"
below20 = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
"Seventeen", "Eighteen", "Nineteen"]
tens = ["", ""... | Bu fonksiyon, rakamlardan oluşan sayıları İngilizce kelimelere çevirerek dilbilgisi kurallarını baştan yazıyor. Sanki ilkokul İngilizce öğretmenimiz sınıfa girmiş de sayıları tek tek okumamızı istiyormuş gibi hissettiren o yorucu süreci bizim yerimize hallediyor. |
def zigzagStringPattern(s, num_rows):
if num_rows == 1:
return s
rows = [""] * num_rows
current_row = 0
direction = -1
for ch in s:
rows[current_row] += ch
if current_row == 0 or current_row == num_rows - 1:
direction = -direction
current_row += direction
... | String'i zikzak düzeninde satırlara dağıtıp sonra bunları birleştiren, yani metni bildiğin orkestra şefi gibi yönetip sıraya sokan bir fonksiyon. Satır sayısı 1 ise hiç uğraşmadan doğrudan orijinal metni basıp 'hadi bakayım işinize' diyen tembel ama iş bitirici bir yapısı var. |
class MinStackDesign:
def __init__(self):
self.stack = []
self.min_stack = []
def push(self, value):
self.stack.append(value)
if not self.min_stack or value <= self.min_stack[-1]:
self.min_stack.append(value)
def pop(self):
value = self.stack.pop()
... | Bu sınıf, eleman ekleyip çıkardığınızda en küçük değeri her an elinin altında tutan bir yığın yapısıdır. Kendi min yığınını ayrı bir köşede besleyerek, en küçük eleman kim diye sürekli liste tarama hamallığından sizi kurtaran bir hizmetkar gibi çalışır. |
class BrowserHistoryDesign:
def __init__(self, homepage):
self.history = [homepage]
self.current = 0
def visit(self, url):
self.history = self.history[:self.current + 1]
self.history.append(url)
self.current += 1
def back(self, steps):
self.current = max(0, ... | Bu class, tarayıcı geçmişini bir listede tutarak ileri ve geri gitmenizi sağlayan simülasyon fonksiyonlarını içerir. İnternette gezintiye çıkıp sonra da kaybolanlar için yapılmış, hafızası balık olanlara ilaç gibi gelen bir sistem. |
class InsertDeleteGetRandomO1:
def __init__(self):
self.values = []
self.index_map = {}
def insert(self, val):
if val in self.index_map:
return False
self.index_map[val] = len(self.values)
self.values.append(val)
return True
def remove(self, val)... | Bu fonksiyon bir liste ve sözlük kullanarak eleman ekleme, silme ve rastgele eleman seçme işlemlerini sabit zamanda yapar. Yani 'bu eleman buradaydı, silerken tüm listeyi kaydırmayayım' diye uyanıklık yaparak listenin son elemanıyla yer değiştirip işini hallediyor, tam bir şark kurnazı. |
class SnapshotArrayDesign:
def __init__(self, length):
self.snap_id = 0
self.history = [[(0, 0)] for _ in range(length)]
def set(self, index, value):
self.history[index].append((self.snap_id, value))
def snap(self):
self.snap_id += 1
return self.snap_id - 1
def... | Bu fonksiyon, dizinin geçmişindeki değerleri snap_id ile dondurarak zaman yolculuğu yapmamızı sağlayan bir yapı kurar. Sanki sürekli fotoğraf çekip 'ben o an bu değerdeydim' diye not alan takıntılı bir tarihçi gibi çalışıyor. |
class EncodeDecodeTinyURL:
def __init__(self):
self.url_map = {}
self.counter = 0
def encode(self, long_url):
self.counter += 1
short = f"http://tiny.url/{self.counter}"
self.url_map[short] = long_url
return short
def decode(self, short_url):
return ... | Uzun URL'leri bir sayaç yardımıyla kısaltıp sözlükte saklayan, geri çağrıldığında ise orijinalini şak diye getiren bir yapı. Sanki koca bir dosyayı sıkıştırıp 'al bunu sakla, lazım olunca açarsın' diyen düzenli ama biraz unutkan bir asistan gibi çalışıyor. |
class RandomPickWithWeight:
def __init__(self, weights):
self.prefix_sums = []
total = 0
for w in weights:
total += w
self.prefix_sums.append(total)
self.total = total
def pick_index(self):
import random, bisect
target = random.uniform(0, ... | Ağırlıklı rastgele seçim yapmak için prefix sum hesaplayıp binary search ile hedef indeksi bulur. Sanki loto makinesinde her topun büyüklüğünü değiştirip yine de adil davranmaya çalışan o şaibeli sistemin yazılım hali gibi çalışıyor. |
def partitionLabelsGreedy(s):
last_occurrence = {ch: i for i, ch in enumerate(s)}
result = []
start = end = 0
for i, ch in enumerate(s):
end = max(end, last_occurrence[ch])
if i == end:
result.append(end - start + 1)
start = i + 1
return result | Bu fonksiyon, string içindeki her karakterin son konumunu hafızaya alıp, karakter gruplarını birbirinden bağımsız parçalara bölen Greedy yaklaşımı kullanır. Sanki bir sınıftaki öğrencileri boylarına göre değil de, son çıkacak olanın kapıyı kapattığı bir düzene sokan titiz bir müdür gibi çalışıyor. |
def taskSchedulerCooldown(tasks, n):
from collections import Counter
counts = Counter(tasks)
max_count = max(counts.values())
max_count_tasks = sum(1 for c in counts.values() if c == max_count)
return max(len(tasks), (max_count - 1) * (n + 1) + max_count_tasks) | Bu fonksiyon, n kadar bekleme süresi kuralıyla görevleri en az kaç birim sürede bitirebileceğimizi hesaplıyor. İş yükünü planlayıp aralara boşluk serpiştiren, sanki mesaiye kalmamak için takla atan bir proje yöneticisi gibi çalışıyor. |
def boatsToSavePeople(people, limit):
people.sort()
left, right = 0, len(people) - 1
boats = 0
while left <= right:
if people[left] + people[right] <= limit:
left += 1
right -= 1
boats += 1
return boats | İnsanları kiloya göre sıralayıp en ağır ve en hafif olanları aynı bota sığdırmaya çalışan iki işaretçi algoritmasıdır. Sanki bota binenler düğüne gidiyor, herkes birbiriyle eşleşip kurtulmaya çalışıyor ama tekne yine de batıyor. |
def permutationsWithDuplicates(nums):
nums.sort()
result = []
used = [False] * len(nums)
def backtrack(path):
if len(path) == len(nums):
result.append(path[:])
return
for i in range(len(nums)):
if used[i]:
continue
if i > 0... | Bu fonksiyon, aynı sayıları barındıran bir listeden tüm benzersiz permütasyonları backtrack algoritması ile türetir. Liste sıralanmış olduğu için aynı sayıları tekrar tekrar deneyip kafa karıştırmaz, sanki aynı elbiseyi giyen ikizleri partiye sokmayan kapıdaki bodyguard gibi davranır. |
def letterCombinationsPhoneNumber(digits):
if not digits:
return []
mapping = {"2": "abc", "3": "def", "4": "ghi", "5": "jkl",
"6": "mno", "7": "pqrs", "8": "tuv", "9": "wxyz"}
result = [""]
for digit in digits:
result = [prefix + letter for prefix in result for letter in ... | Telefon tuş takımındaki rakamlara basıldığında oluşabilecek tüm harf kombinasyonlarını Cartesian çarpım mantığıyla üretir. Tıpkı eski Nokia'da mesaj yazmaya çalışırken çektiğimiz o bitmek bilmeyen çile gibi tüm seçenekleri önümüze seriyor. |
def generateValidParenthesesCombinations(n):
result = []
def backtrack(current, open_count, close_count):
if len(current) == 2 * n:
result.append(current)
return
if open_count < n:
backtrack(current + "(", open_count + 1, close_count)
if close_count <... | Backtracking algoritması kullanarak n çift parantezin tüm geçerli kombinasyonlarını üretir. İç içe geçmiş parantezlerle uğraşmaktan beyni yananlara, bilgisayara 'sen yap şu işi' demek için yazılmış bir fonksiyon. |
def minimumSizeSubarraySum(target, nums):
left = 0
total = 0
min_len = float("inf")
for right, num in enumerate(nums):
total += num
while total >= target:
min_len = min(min_len, right - left + 1)
total -= nums[left]
left += 1
return min_len if min_... | Sliding Window yöntemiyle toplamı hedef sayıya eşit veya büyük olan en küçük alt dizinin uzunluğunu bulur. Liste içinde oradan oraya koşan bu elemanlar, sanki bedava yemek kuyruğunda yer kapmaya çalışan insanlar gibi sürekli birbirini eziyor. |
def accountsMergeUnionFind(accounts):
parent = list(range(len(accounts)))
def find(x):
while parent[x] != x:
parent[x] = parent[parent[x]]
x = parent[x]
return x
def union(x, y):
parent[find(x)] = find(y)
email_to_index = {}
for i, account in enumer... | Union-Find veri yapısını kullanarak aynı kişiye ait e-posta hesaplarını tek bir çatı altında birleştirir. Birbirlerine küsmüş dostları barıştırmaya çalışan salih bir isan gibi. |
def numberOfProvincesMatrix(is_connected):
n = len(is_connected)
visited = [False] * n
def dfs(node):
visited[node] = True
for neighbor in range(n):
if is_connected[node][neighbor] == 1 and not visited[neighbor]:
dfs(neighbor)
provinces = 0
for i in rang... | Bu fonksiyon, birbirine bağlı düğümlerden oluşan bir matris üzerinde derinlik öncelikli arama (DFS) yaparak toplam bağımsız bileşen sayısını hesaplar. Yani aslında kim kiminle arkadaş, kim kiminle kanka diye bakıp grupları sayan bir dedikodu mekanizması gibi çalışıyor. |
def satisfiabilityEqualityEquations(equations):
parent = {}
def find(x):
parent.setdefault(x, x)
while parent[x] != x:
parent[x] = parent[parent[x]]
x = parent[x]
return x
def union(x, y):
parent[find(x)] = find(y)
for eq in equations:
i... | Disjoint Set Union algoritmasını kullanarak değişkenlerin birbirine eşit olup olmadığını kontrol eder. Eşitlikleri aynı kümeye toplayıp sonra eşitsizlikleri kontrol ederek, birbirine zıt düşenleri yakalayan tam bir dedektif gibi çalışan fonksiyon. |
def gameOfLifeSimulation(board):
rows, cols = len(board), len(board[0])
def count_neighbors(r, c):
count = 0
for dr in (-1, 0, 1):
for dc in (-1, 0, 1):
if dr == 0 and dc == 0:
continue
nr, nc = r + dr, c + dc
if 0 <... | Hücrelerin komşu sayısına bakarak hayatta kalıp kalmayacağına karar veren klasik Game of Life algoritması. Kendi başına bir ekosistem kurmuş, ölümü ve yaşamı iki if-else bloğuna sığdırmayı başarmış çılgın bir simülasyon fonksiyonu. |
def rottingOrangesMultiSourceBFS(grid):
rows, cols = len(grid), len(grid[0])
queue = []
fresh = 0
for r in range(rows):
for c in range(cols):
if grid[r][c] == 2:
queue.append((r, c, 0))
elif grid[r][c] == 1:
fresh += 1
minutes = 0
w... | Bu kod, çürük portakalların sağlıklı olanlara bulaşıcı hastalık gibi yayıldığı süreyi BFS algoritmasıyla hesaplıyor. Karantina kurallarını hiçe sayıp tüm manavı çürüten bu fonksiyon, sağlam portakal kalmadığında toplam süreyi, yoksa hüsranı döndürüyor. |
def fillDistanceToNearestGate(rooms):
rows, cols = len(rooms), len(rooms[0])
queue = [(r, c) for r in range(rows) for c in range(cols) if rooms[r][c] == 0]
while queue:
r, c = queue.pop(0)
for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
nr, nc = r + dr, c + dc
if 0 ... | BFS algoritmasını kullanarak boş odaların en yakın kapıya olan uzaklığını hesaplayan fonksiyon. Kapıları başlangıç noktası alıp, sanki dedikodu yayar gibi odaya en yakın çıkış mesafesini adım adım her hücreye işleyen bir emlakçı gibi çalışıyor. |
def pacificAtlanticWaterFlow(heights):
if not heights:
return []
rows, cols = len(heights), len(heights[0])
pacific, atlantic = set(), set()
def dfs(r, c, visited, prev_height):
if (r, c) in visited or r < 0 or r >= rows or c < 0 or c >= cols or heights[r][c] < prev_height:
... | Bu fonksiyon, bir haritadaki yükseklik değerlerini kullanarak suyun hem Pasifik hem de Atlantik okyanusuna akabileceği noktaları DFS algoritmasıyla bulur. Yani okyanuslar arası diplomatik kriz çıkaran o 'her yere akarım' diyen suların koordinatlarını avlayan tam bir memur zihniyetli kod parçası. |
def burstBalloonsIntervalDP(nums):
balloons = [1] + nums + [1]
n = len(balloons)
dp = [[0] * n for _ in range(n)]
for length in range(2, n):
for left in range(0, n - length):
right = left + length
for k in range(left + 1, right):
dp[left][right] = max(
... | Bu fonksiyon, Interval DP kullanarak balon patlatma oyununda alınabilecek maksimum puanı hesaplar. Kendi çapında strateji geliştiren bu arkadaş, hangi balonu önce patlatırsam daha çok puan alırım diye tüm kombinasyonları inceleyip sizi gereksiz bir düşünce yükünden kurtarıyor. |
def stoneGameDP(piles):
n = len(piles)
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = piles[i]
for length in range(2, n + 1):
for i in range(n - length + 1):
j = i + length - 1
dp[i][j] = max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1])
re... | Dinamik programlama kullanarak oyuncuların maksimum taş toplama farkını hesaplayan bu fonksiyon, rakibinizin bir sonraki hamlesini tahmin etmeye çalışan çok bilmiş bir yapıda. Taş çalma yarışında kimin daha kurnaz olduğunu görmek için matrisler arası mekik dokuyan tam bir strateji canavarı. |
def predictTheWinnerDP(nums):
n = len(nums)
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = nums[i]
for length in range(2, n + 1):
for i in range(n - length + 1):
j = i + length - 1
dp[i][j] = max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1])
... | Bu fonksiyon dinamik programlama kullanarak iki oyuncunun stratejik oyununda kazananı belirler. Sanki bakkaldan mal kaçırır gibi sırayla en avantajlı sayıyı seçip, sonunda kimin cebinde daha fazla leblebi kaldığına bakan bir cimri hesap makinesi. |
def scrambleStringDP(s1, s2):
memo = {}
def helper(a, b):
if (a, b) in memo:
return memo[(a, b)]
if a == b:
return True
if sorted(a) != sorted(b):
memo[(a, b)] = False
return False
n = len(a)
for i in range(1, n):
... | Bu fonksiyon, iki stringin birbirinin karıştırılmış hali olup olmadığını anlamak için dinamik programlama kullanır. Parçaları sürekli bölüp bölüp birbirine eşitleyerek, senin evdeki çorap çiftlerini ayırmaya çalışan annenden daha detaylı kontrol yapıyor. |
def bestTimeToBuySellStockKTransactions(k, prices):
if not prices:
return 0
n = len(prices)
if k >= n // 2:
return sum(max(prices[i + 1] - prices[i], 0) for i in range(n - 1))
dp = [[0] * n for _ in range(k + 1)]
for t in range(1, k + 1):
max_diff = -prices[0]
for d i... | Bu fonksiyon k kadar işlem hakkı vererek hisse senedinden elde edilebilecek maksimum kârı hesaplar. Kâr hırsıyla yanıp tutuşan borsacıların elindeki tüm parayı sıfırlamadan önce doğru zamanda al-sat yapmasını sağlayan bir hesap makinesi gibi çalışıyor. |
def utf8ValidationBitCheck(data):
remaining = 0
for num in data:
byte = num & 0xFF
if remaining == 0:
if byte >> 7 == 0:
continue
elif byte >> 5 == 0b110:
remaining = 1
elif byte >> 4 == 0b1110:
remaining = 2
... | Bu fonksiyon, gelen bayt dizisinin geçerli bir UTF-8 karakter kodlaması olup olmadığını bit seviyesinde denetler. İçeriye giren veriyi sanki bir gümrük memuruymuş gibi didik didik kontrol edip, kurala uymayan baytları kapıdan çevirerek False döndüren disiplinli bir bekçi gibi çalışıyor. |
def maximalRectangleBinaryMatrix(matrix):
if not matrix:
return 0
cols = len(matrix[0])
heights = [0] * cols
max_area = 0
def largest_rectangle(hist):
stack = []
max_a = 0
hist = hist + [0]
for i, h in enumerate(hist):
while stack and hist[stack[-... | Bu fonksiyon ikili matris içindeki 1'lerden oluşan en büyük dikdörtgenin alanını, her satırı bir histogram olarak işleyerek hesaplar. Bir nevi matris içinde saklanan 1'leri bir araya toplayıp 'kimin alanı daha büyük' diye iddiaya tutuşan, oldukça çalışkan bir mimar kendisi. |
def numberOfIslandsPerimeter(grid):
rows, cols = len(grid), len(grid[0])
perimeter = 0
for r in range(rows):
for c in range(cols):
if grid[r][c] == 1:
perimeter += 4
if r > 0 and grid[r - 1][c] == 1:
perimeter -= 2
if c ... | Bu fonksiyon grid üzerindeki 1 değerine sahip hücrelerin toplam çevresini hesaplar, komşu olan her bir kenarı sistemden düşerek çifte sayımı engeller. Kareleri yan yana dizip birbirinin sırtına binen kenarları görmezden gelen, yani harita okumaktan ziyade inşaat işleriyle uğraşan bir kod parçası. |
class AllOneDataStructure:
def __init__(self):
self.counts = {}
def inc(self, key):
self.counts[key] = self.counts.get(key, 0) + 1
def dec(self, key):
if key in self.counts:
self.counts[key] -= 1
if self.counts[key] == 0:
del self.counts[key]... | Bu sınıf, anahtarların kaç kez tekrarlandığını takip ederek en sık ve en seyrek kullanılanları bulan bir yapı sunuyor. Sanki biri gelip sürekli 'bunu bir daha alalım' dediğinde çetele tutan o takıntılı arkadaşınız gibi çalışıyor. |
def findKPairsWithSmallestSums(nums1, nums2, k):
import heapq
if not nums1 or not nums2:
return []
heap = [(nums1[i] + nums2[0], i, 0) for i in range(min(k, len(nums1)))]
heapq.heapify(heap)
result = []
while heap and len(result) < k:
total, i, j = heapq.heappop(heap)
res... | İki ayrı listeden elemanları toplayıp en küçük toplamı veren k çifti bulan, öncelik kuyruğu kullanan bir algoritma. İki listenin elemanlarını sanki evde yemek kalmamış gibi en küçükleri seçerek tabak tabak önümüze getiren obur bir fonksiyon. |
def ipoMaximizeCapital(k, initial_capital, profits, capital):
import heapq
projects = sorted(zip(capital, profits))
available = []
idx = 0
current_capital = initial_capital
for _ in range(k):
while idx < len(projects) and projects[idx][0] <= current_capital:
heapq.heappush(av... | Mevcut sermayenle gücünün yettiği projeleri seçip karını maksimize eden bu fonksiyon, yatırımcılar için bir nevi dijital finans danışmanı gibi çalışıyor. Kısacası paran yoksa kapıdan kovuluyorsun, paran varsa da en karlı işi bulup cebini dolduruyorsun. |
def shortestPathBinaryMatrixBFS(grid):
n = len(grid)
if grid[0][0] == 1 or grid[n - 1][n - 1] == 1:
return -1
queue = [(0, 0, 1)]
visited = {(0, 0)}
directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
while queue:
r, c, dist = queue.pop(0)
... | BFS algoritmasını kullanarak grid üzerinde başlangıçtan bitişe en kısa yolu bulan fonksiyon. Sanki labirentte çıkışı arayan sarhoş gibi her yöne bakıp, duvara toslamadığı her yolu tek tek deniyor. |
def criticalPathMethodScheduling(tasks, dependencies):
graph = {t: [] for t in tasks}
in_degree = {t: 0 for t in tasks}
for u, v in dependencies:
graph[u].append(v)
in_degree[v] += 1
earliest_finish = {t: tasks[t] for t in tasks}
queue = [t for t in tasks if in_degree[t] == 0]
or... | Bu fonksiyon, işlerin birbirine bağlı olduğu bir ortamda toplam süreyi hesaplayan meşhur kritik yol algoritmasıdır. İşleri sıraya dizip hangisinin diğerini beklediğini kontrol ediyor, yani aslında tam bir 'seni beklemeden işe başlayamam' tribi yaşatıyor. |
class BinaryIndexedTree2D:
def __init__(self, rows, cols):
self.rows = rows
self.cols = cols
self.tree = [[0] * (cols + 1) for _ in range(rows + 1)]
def update(self, row, col, delta):
i = row + 1
while i <= self.rows:
j = col + 1
while j <= self.c... | İki boyutlu bir matriste elemanları güncelleyip önek toplamlarını hızlıca hesaplayan Fenwick Tree yapısıdır. Kendi kendine bitwise operasyonlarla yolunu bulmaya çalışan, matris üzerinde adeta labirentte koşar gibi dolaşan bir algoritma. |
class LazyPropagationSegmentTree:
def __init__(self, arr):
self.n = len(arr)
self.tree = [0] * (4 * self.n)
self.lazy = [0] * (4 * self.n)
self._build(arr, 1, 0, self.n - 1)
def _build(self, arr, node, start, end):
if start == end:
self.tree[node] = arr[start... | Bu Segment Tree yapısı, bir aralıktaki toplamları logaritmik sürede güncellerken işi sonraya bırakan 'lazy propagation' tekniğini kullanır. Yani sizin gibi üşengeç, yapılacak işleri sürekli erteleyen bir öğrencinin yazılım dünyasındaki karşılığıdır. |
def sqrtDecompositionRangeSum(arr, queries):
import math
n = len(arr)
block_size = int(math.sqrt(n)) + 1
blocks = [0] * (block_size + 1)
for i in range(n):
blocks[i // block_size] += arr[i]
results = []
for l, r in queries:
total = 0
start_block = l // block_size
... | Bu kod, uzun bir listeyi karekök boyutunda bloklara bölerek aralıklı toplam hesaplamasını hızlandıran Sqrt Decomposition algoritmasıdır. Yani koca bir kütüphaneyi rastgele aramak yerine, raflara bölüp nokta atışı yapan bir kütüphaneci gibi davranıyor, işi gücü işleri hızlandırmak. |
def eulerTourTreeFlatten(n, edges, root=0):
graph = {i: [] for i in range(n)}
for u, v in edges:
graph[u].append(v)
graph[v].append(u)
tin = [0] * n
tout = [0] * n
timer = [0]
visited = [False] * n
def dfs(node, parent):
visited[node] = True
tin[node] = timer... | DFS ile her düğüm için giriş zamanı (tin) ve alt ağacın DFS tamamlanma zamanını (tout) kaydeder. Çıktı doğrudan düzleştirilmiş dizi değil, düğümlerin Euler turundaki giriş ve çıkış zamanlarını temsil eden iki dizidir. |
def shortestPathEliminatingObstacles(grid, k):
rows, cols = len(grid), len(grid[0])
if k >= rows + cols - 2:
return rows + cols - 2
visited = {(0, 0, k)}
queue = [(0, 0, k, 0)]
while queue:
r, c, remaining_k, steps = queue.pop(0)
if r == rows - 1 and c == cols - 1:
... | BFS algoritmasını kullanarak grid üzerinde duvarları kırma hakkını da hesaba katan en kısa yolu bulur. Sanki labirentte duvara toslayınca bayılmak yerine elindeki balyozla duvarları yıkarak hedefe koşan gözü dönmüş bir yazılımcı gibi çalışıyor. |
def countIslandsDistinctShapes(grid):
rows, cols = len(grid), len(grid[0])
visited = [[False] * cols for _ in range(rows)]
shapes = set()
def dfs(r, c, origin, shape):
if r < 0 or r >= rows or c < 0 or c >= cols or visited[r][c] or grid[r][c] == 0:
return
visited[r][c] = Tru... | Bu fonksiyon, ızgara üzerindeki kara parçalarının şekillerini DFS algoritmasıyla kaydedip, birbirine benzemeyen kaç farklı ada tipi olduğunu buluyor. Yani dünyayı geziyor ama her farklı manzarayı bir kere not edip, aynısından bin tane de olsa 'ben bunu gördüm' diyerek sadece özgün olanları sayıyor. |
def allTopologicalOrderings(n, edges):
graph = {i: [] for i in range(n)}
in_degree = [0] * n
for u, v in edges:
graph[u].append(v)
in_degree[v] += 1
result = []
visited = [False] * n
def backtrack(path):
if len(path) == n:
result.append(path[:])
... | Bu fonksiyon, bir yönlü grafikteki tüm olası topolojik sıralamaları backtrack yöntemiyle tek tek listeler. Sanki karmaşık işleri hangi sırayla yapacağını bulamayan kararsız bir proje yöneticisi gibi, tüm olasılıkları zorla önümüze seriyor. |
def eulerianCircuitHierholzer(n, edges):
graph = {i: [] for i in range(n)}
for u, v in edges:
graph[u].append(v)
graph[v].append(u)
circuit = []
stack = [0]
local_graph = {k: list(v) for k, v in graph.items()}
while stack:
node = stack[-1]
if local_graph[node]:
... | Hierholzer algoritmasını kullanarak graf üzerinde her kenarı tam bir kez ziyaret eden o efsanevi döngüyü bulur. Stack ile düğümleri gezerken yediği yolu unutmamak için not alan, kendi çapında hafızası kuvvetli bir fonksiyon. |
def kCoreDecompositionGraph(n, edges, k):
graph = {i: set() for i in range(n)}
for u, v in edges:
graph[u].add(v)
graph[v].add(u)
removed = set()
changed = True
while changed:
changed = False
for node in range(n):
if node not in removed and len(graph[node... | Bu fonksiyon, bir grafikteki düğümlerin derecesini kontrol ederek k-çekirdeğini bulur ve k'dan az komşusu olan düğümleri yavaş yavaş sistemden şutlar. Sosyal medyada takipçi sayısı k'nın altına düşenleri direkt arkadaş listesinden silen o acımasız arkadaşınız gibi çalışıyor. |
def stableMarriageGaleShapley(men_prefs, women_prefs):
free_men = list(men_prefs.keys())
engaged = {}
next_proposal = {man: 0 for man in men_prefs}
while free_men:
man = free_men.pop(0)
woman = men_prefs[man][next_proposal[man]]
next_proposal[man] += 1
if woman not in en... | Gale-Shapley algoritmasını kullanarak tarafların tercihlerine göre istikrarlı eşleşmeler bulan bu fonksiyon, kimsenin birbirini aldatmayacağı bir düzen kurar. Görücü usulü evliliklerin yazılım dünyasındaki karşılığıdır; herkes en iyi adayına gitmeye çalışırken ortalık biraz karışıyor ama sonunda herkes birine paslanıyo... |
def maxWidthOfBinaryTree(root):
if not root:
return 0
max_width = 0
queue = [(root, 0)]
while queue:
level_size = len(queue)
_, first_idx = queue[0]
last_idx = first_idx
for _ in range(level_size):
node, idx = queue.pop(0)
last_idx = idx
... | Binary tree’nin her seviyesindeki düğümlere sanal dizi indeksleri vererek en soldaki ve en sağdaki düğüm arasındaki aralığın genişliğini hesaplar. Bu nedenle arada gerçek düğüm bulunmayan konumlar da genişlik hesabına dahil edilir. |
def kthLargestElementQuickSelect(nums, k):
import random
target = len(nums) - k
lo, hi = 0, len(nums) - 1
while True:
pivot = nums[random.randint(lo, hi)]
left, mid, right = lo, lo, hi
while mid <= right:
if nums[mid] < pivot:
nums[left], nums[mid] = n... | QuickSelect algoritmasını kullanarak listenin içindeki k'nıncı büyük elemanı hızlıca bulmaya yarar. Rastgele bir pivot seçip listeyi sağa sola çekiştirerek, sanki düğün salonunda yer kapmaca oynayan akrabalar gibi hedef elemana odaklanır. |
def maximumGapBucketSort(nums):
if len(nums) < 2:
return 0
lo, hi = min(nums), max(nums)
if lo == hi:
return 0
n = len(nums)
bucket_size = max(1, (hi - lo) // (n - 1))
bucket_count = (hi - lo) // bucket_size + 1
buckets_min = [None] * bucket_count
buckets_max = [None] * b... | Bu fonksiyon, sıralanmış dizideki ardışık sayılar arasındaki en büyük farkı bulmak için sayılara kova metaforu uygulayan akıllı bir yöntemdir. Sanki sayıları kafasına göre kovalarla ayırıp 'kimin arasında daha çok mesafe var' diye didik didik arayan çok meraklı bir dedektif gibi çalışıyor. |
def countBattleshipsInGrid(board):
rows, cols = len(board), len(board[0])
count = 0
for r in range(rows):
for c in range(cols):
if board[r][c] != "X":
continue
if r > 0 and board[r - 1][c] == "X":
continue
if c > 0 and board[r][c - ... | Bu fonksiyon ızgaradaki savaş gemilerini sayarken, sadece her geminin sol üst köşesindeki X işaretine bakarak mükerrer sayımları engelliyor. Gemileri tek parça kabul edip sadece başını yakalayan, bizim ilkokuldaki yoklama alan öğretmene benzeyen bir mantık. |
def buildLargestNumberFromDigits(nums):
from functools import cmp_to_key
nums_str = list(map(str, nums))
nums_str.sort(key=cmp_to_key(lambda a, b: -1 if a + b > b + a else 1))
result = "".join(nums_str).lstrip("0")
return result if result else "0" | Bu fonksiyon sayıları stringleştirip öyle bir sıralıyor ki, yan yana geldiklerinde oluşturabilecekleri en büyük sayıyı ortaya çıkarıyor. Sayıların birbiriyle yarışıp koltuk kapmaya çalıştığı, en sona kalan sıfırların ise kovulduğu acımasız bir kariyer basamağı gibi düşünebilirsin. |
def minimumDominoRotations(tops, bottoms):
def check(target):
rotations_top = rotations_bottom = 0
for i in range(len(tops)):
if tops[i] != target and bottoms[i] != target:
return -1
elif tops[i] != target:
rotations_top += 1
elif b... | Dominoları devirmeden herkesi aynı sayıya eşitlemek için gereken minimum hamle sayısını hesaplayan bir fonksiyon. Eğer domino taşları inat edip senin istediğin sayıya dönmüyorsa, 'bu iş olmaz' deyip -1 döndüren pesimist bir arkadaşımızdır. |
def minimumOperationsToEqualArray(nums):
unique_positive = set(n for n in nums if n > 0)
return len(unique_positive) | Listedeki pozitif değerlerin kaç farklı değerden oluştuğunu hesaplar. Kod diziyi değiştirmez; pozitif değerleri bir kümeye dönüştürerek yalnızca benzersiz pozitif değerlerin sayısını döndürür. |
def maxProfitAssignment(difficulty, profit, worker):
jobs = sorted(zip(difficulty, profit))
worker.sort()
total = 0
best = 0
i = 0
for w in worker:
while i < len(jobs) and jobs[i][0] <= w:
best = max(best, jobs[i][1])
i += 1
total += best
return total | Bu fonksiyon, işçilerin yeteneklerine göre en yüksek kârı getiren görevleri eşleştirerek toplam kazancı hesaplıyor. İşçileri ve işleri sıralayıp aç gözlü bir yaklaşımla en iyi teklifi seçen, tam bir kariyer koçu gibi çalışan fonksiyon. |
def countNumbersWithUniqueDigits(n):
if n == 0:
return 1
total = 10
unique_digits = 9
available_digits = 9
while n > 1 and available_digits > 0:
unique_digits *= available_digits
total += unique_digits
available_digits -= 1
n -= 1
return total | En fazla n basamaklı, rakamları birbirinden farklı olan sayıların toplam sayısını hesaplar; 0 da ayrı bir sayı olarak dahil edilir. n arttıkça her yeni basamak için kullanılabilecek henüz seçilmemiş rakamların sayısı azalır. |
def isBalancedBinaryTree(root):
def check(node):
if not node:
return 0
left = check(node.left)
if left == -1:
return -1
right = check(node.right)
if right == -1:
return -1
if abs(left - right) > 1:
return -1
retu... | İkili ağacın her düğümünde sol ve sağ alt ağaç yüksekliklerinin farkını kontrol eder ve bu fark hiçbir yerde 1’den büyük değilse True, aksi halde False döndürür. İç fonksiyon başarısızlık durumunu -1 ile temsil etse de dışarıya boolean sonuç döndürülür. |
class MedianFinderTwoHeaps:
def __init__(self):
import heapq
self.small = []
self.large = []
def add_num(self, num):
import heapq
heapq.heappush(self.small, -num)
heapq.heappush(self.large, -heapq.heappop(self.small))
if len(self.large) > len(self.small):... | Bu sınıf, Two Heaps algoritmasıyla sayıları iki ayrı heap üzerinde dengede tutarak anlık veri akışının ortanca değerini bulur. Sayıları sürekli zengin ve fakir diye iki gruba ayırıp, denge bozulmasın diye aralarında gizlice adam transfer eden arabulucu gibidir. |
class ListNodeSimple:
def __init__(self, value):
self.value = value
self.next = None
def reverseLinkedListInGroupsOfK(head, k):
node = head
count = 0
while node and count < k:
node = node.next
count += 1
if count < k:
return head
prev = None
current ... | Bağlı listeyi k'şerli gruplara bölerek her parçayı özyinelemeli olarak ters çeviren fonksiyondur. Sonda k kadar eleman toplayamazsa 'eksik kadroyla iş yapmam' deyip kalan gruba hiç dokunmadan aynen iade eder. |
class TimeBasedKeyValueStore:
def __init__(self):
self.store = {}
def set(self, key, value, timestamp):
self.store.setdefault(key, []).append((timestamp, value))
def get(self, key, timestamp):
import bisect
if key not in self.store:
return ""
records = s... | Verilen anahtara bağlı değerleri zaman damgasıyla saklayıp, bisect yardımıyla binary search yaparak istenen andaki değeri getirir. Eski defterleri saniyesi saniyesine tutup 'sen o zaman bunu demiştin' diye arşivden çıkaran kindar bir veri yapısı. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.