0Pricing
DSA Interview Prep · Ders

Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar

Altı bit düzeyi işlecin tümünü doğruluk tabloları ve Python örnekleriyle gözden geçirin; sola ve sağa kaydırmaların ikiyle çarpma ve bölmeyle ilişkisini anlayın.

Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar, CoddyKit'te ücretsiz bir DSA Interview Prep dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, DSA Interview Prep öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. DSA Interview Prep kursu toplamda 4 dersten oluşur.

Bit İşlemleri Neden Önemlidir

Bit işlemleri, doğrudan tamsayıların ikili gösterimi üzerinde işlem yapmanızı sağlar. Karmaşık görünen birçok problem, doğru bit düzeyi hileyle kolaylaşır: O(n) zamanda ve O(1) alanda eksik sayıyı bulmak, değişkenleri geçici bir değişken kullanmadan yer değiştirmek veya alt kümeleri kompakt biçimde kodlamak gibi. Mülakat yapanlar, düşük seviyeli anlayışı ve yaratıcı düşünmeyi ölçmek için bu problemleri kullanır.

Python tamsayıları sınırsız duyarlılığa sahiptir; belleğin izin verdiği kadar büyük olabilirler. Ancak bit işlemleri donanım düzeyinde her zaman standart iki'nin tümleyeni anlamını izler. Altı işlecin tamamı, tamsayıların ikili gösterimleri üzerinde bit bit çalışır.

# All six bitwise operators in Python
a, b = 0b1010, 0b1100  # 10 and 12 in decimal
print(f'a = {bin(a)} = {a}')
print(f'b = {bin(b)} = {b}')
print(f'a & b  (AND) = {bin(a & b)} = {a & b}')   # 1000 = 8
print(f'a | b  (OR)  = {bin(a | b)} = {a | b}')   # 1110 = 14
print(f'a ^ b  (XOR) = {bin(a ^ b)} = {a ^ b}')   # 0110 = 6
print(f'~a     (NOT) = {~a}')                       # -11 (two's complement)
print(f'a << 1 (LSH) = {bin(a << 1)} = {a << 1}') # 10100 = 20
print(f'a >> 1 (RSH) = {bin(a >> 1)} = {a >> 1}') # 101 = 5

AND İşleci: Bit Maskeleme

AND işleci (&), yalnızca her iki girdi biti de 1 olduğunda 1 üretir. Temel kullanım amacı maskelemedir: diğer tüm bitleri sıfırlarken bir sayının belirli bitlerini seçmek. n sayısında k bitinin ayarlanmış olup olmadığını kontrol etmek için n & (1 << k) ifadesini değerlendirin; sonuç sıfır değilse k biti 1'dir.

AND, en düşük ayarlanmış biti temizlemek için de kullanılır: n & (n - 1) ifadesi en sağdaki 1 bitini kaldırır. Bu yöntem, ayarlanmış bitleri verimli biçimde saymak ve bir sayının ikinin kuvveti olup olmadığını kontrol etmek için kullanılır (ikinin kuvvetinde tam olarak bir ayarlanmış bit bulunur; dolayısıyla n & (n-1) == 0 olur).

n = 0b10110100  # 180

# Check if bit 5 is set (0-indexed from right)
bit_5 = (n >> 5) & 1
print(f'Bit 5 of {n}: {bit_5}')  # 1

# Clear lowest set bit
print(f'n = {bin(n)}')
print(f'n & (n-1) = {bin(n & (n-1))}')  # 10110000, removed the '100'

# Check power of two
for x in [16, 15, 8, 6, 1, 0]:
    is_pow2 = x > 0 and (x & (x - 1)) == 0
    print(f'{x}: power of 2 = {is_pow2}')

OR İşleci: Bitleri Ayarlama

OR işleci (|), en az bir girdi biti 1 olduğunda 1 üretir. Temel kullanım amacı, diğer bitleri etkilemeden belirli bir biti 1 yapmaktır. n sayısında k bitini ayarlamak için n | (1 << k) kullanın. k konumuna kaydırılan 1, o biti etkinleştirir; 0 ile OR işlemine giren her şey aynı kaldığı için diğer tüm bitler değişmeden kalır.

OR, bayrakları birleştirmek için de kullanılır: özellik bayraklarını ayrı bitler olarak temsil ediyorsanız, OR ile birden çok bayrağı etkinleştirebilirsiniz. Örneğin READ | WRITE | EXECUTE, üç izin bitini tek bir tamsayıda birleştirir.

# Set bit k in n
def set_bit(n, k):
    return n | (1 << k)

n = 0b1000  # 8
print(f'Original: {bin(n)}')
print(f'Set bit 1: {bin(set_bit(n, 1))}')  # 1010
print(f'Set bit 0: {bin(set_bit(n, 0))}')  # 1001

# Flag combination example
READ    = 0b001  # 1
WRITE   = 0b010  # 2
EXECUTE = 0b100  # 4

perms = READ | EXECUTE
print(f'READ|EXECUTE permissions: {bin(perms)} = {perms}')
print(f'Has READ:    {bool(perms & READ)}')
print(f'Has WRITE:   {bool(perms & WRITE)}')
print(f'Has EXECUTE: {bool(perms & EXECUTE)}')

XOR İşleci: Değiştirme ve Fark

XOR işleci (^), girdi bitleri farklı olduğunda 1 üretir. XOR'un üç güçlü cebirsel özelliği vardır: a ^ a = 0 (aynı girdiler birbirini götürür), a ^ 0 = a (sıfır etkisiz elemandır) ve XOR hem değişme hem de birleşme özelliğine sahiptir. Bu özellikler, XOR'u tekil öğeleri bulmak için başvurulacak araç hâline getirir.

XOR, belirli bir biti değiştirmek için de kullanılır: n ^ (1 << k), diğer bitleri değiştirmeden k bitini tersine çevirir. k biti 0 ise 1'e, 1 ise 0'a dönüşür.

# XOR properties
print(5 ^ 5)    # 0 — same values cancel
print(5 ^ 0)    # 5 — zero is identity
print(5 ^ 3 ^ 3)  # 5 — 3 cancels itself

# Toggle bit k
def toggle_bit(n, k):
    return n ^ (1 << k)

n = 0b1010
print(f'Toggle bit 3: {bin(toggle_bit(n, 3))}')  # 0010 (was 1)
print(f'Toggle bit 0: {bin(toggle_bit(n, 0))}')  # 1011 (was 0)

# XOR swap without temp variable
a, b = 7, 13
a = a ^ b
b = a ^ b   # b now gets original a
a = a ^ b   # a now gets original b
print(f'After XOR swap: a={a}, b={b}')  # a=13, b=7

NOT İşleci ve İki'nin Tümleyeni

NOT işleci (~) tüm bitleri tersine çevirir. Python'da iki'nin tümleyeni gösterimi nedeniyle ~n, -(n+1) değerine eşittir. Bu, birçok kişiyi şaşırtır: ~5 = -6 olur; safça beklenebilecek 0b11111010 değil. Python tamsayıları sonsuz duyarlığa sahip olduğundan pozitif bir sayının tüm bitlerini tersine çevirmek, iki'nin tümleyeninde negatif bir sonuç verir.

Uygulamada Python'da bit işlemleri için ~ işlecini tek başına nadiren kullanırsınız. Bunun yerine belirli bitleri temizlemek için AND ile birlikte kullanın veya bit genişliğini belirli bir bit sayısıyla sınırlayan ~n & mask ifadesini hesaplayın (örneğin 32 bit için & 0xFFFFFFFF).

# NOT in Python: ~n = -(n+1)
for n in [0, 1, 5, 127]:
    print(f'~{n} = {~n}')   # all give -(n+1)

# Clear bit k using NOT
def clear_bit(n, k):
    return n & ~(1 << k)

n = 0b1111
print(f'Clear bit 2: {bin(clear_bit(n, 2))}')  # 1011
print(f'Clear bit 0: {bin(clear_bit(n, 0))}')  # 1110

# Limiting to 32-bit with mask
def bitwise_not_32(n):
    return ~n & 0xFFFFFFFF

print(f'32-bit NOT of 5: {bin(bitwise_not_32(5))}')  # 32 zeros then ones

Sola Kaydırma: İkinin Kuvvetleriyle Çarpma

Sola kaydırma işleci (<<), tüm bitleri k konum sola kaydırır ve boşalan sağ konumları sıfırlarla doldurur. Bu, 2^k ile çarpmaya eşdeğerdir. 1 konum sola kaydırma değeri iki katına çıkarır; k konum sola kaydırma ise değeri 2^k ile çarpar.

Mülakat problemlerinde sola kaydırma çoğunlukla bit maskeleri oluşturmak için kullanılır: 1 << k, yalnızca k biti ayarlanmış bir sayı oluşturur. Bu, tüm bit işlemlerinin temelidir; tek tek bitleri ayarlama, temizleme, değiştirme ve kontrol etme işlemlerinin tamamı 1 << k ile başlar.

# Left shift = multiply by 2^k
n = 1
for k in range(8):
    print(f'1 << {k} = {1 << k}')   # 1,2,4,8,16,32,64,128

# Practical use: creating bitmasks
def bit_mask(k):
    return 1 << k

print(f'\nBitmask for bit 0: {bin(bit_mask(0))}')  # 1
print(f'Bitmask for bit 3: {bin(bit_mask(3))}')  # 1000
print(f'Bitmask for bit 7: {bin(bit_mask(7))}')  # 10000000

# Fast exponentiation: 2^10 = 1024
print(f'2^10 = {1 << 10}')  # 1024

Sağa Kaydırma: İkinin Kuvvetlerine Bölme

Sağa kaydırma işleci (>>), tüm bitleri k konum sağa kaydırır ve en sağdaki k biti atar. Bu, 2^k ile tamsayı bölmesine eşdeğerdir. Python'da sağa kaydırma her zaman aritmetiktir: en soldaki bitler işaret bitiyle doldurulur (pozitif sayılarda 0, negatif sayılarda 1).

Yaygın bir mülakat hilesi şudur: n sayısından k bitini çıkarmak için (n >> k) & 1 kullanın. Bu işlem k bitini 0 konumuna indirir ve diğer tüm bitleri maskeler. Tam bir maske hesaplayıp karşılaştırmaya gerek kalmadan belirli bir biti kontrol etmenin en temiz yoludur.

# Right shift = integer division by 2^k
n = 64
for k in range(7):
    print(f'{n} >> {k} = {n >> k}')   # 64,32,16,8,4,2,1

# Extract bit k from n
def get_bit(n, k):
    return (n >> k) & 1

n = 0b10110101  # 181
print(f'\nBits of {n} ({bin(n)}):')
for k in range(8):
    print(f'  Bit {k}: {get_bit(n, k)}')

# Negative number right shift (arithmetic)
print(f'-8 >> 1 = {-8 >> 1}')   # -4 (fills with sign bit 1)

Pratik Bit Hileleri Özeti

Mülakatlarda karşılaşacağınız en yaygın bit işlemi kalıplarından bir derleme aşağıdadır. Bu kalıpları ezberleyin; onlarca problemde tekrar tekrar karşınıza çıkarlar:

  • n & 1 — n'nin tek olup olmadığını kontrol etme
  • n & (n-1) — en düşük ayarlanmış biti temizleme
  • n & -n — en düşük ayarlanmış biti ayırma
  • n | (1 << k) — k bitini ayarlama
  • n & ~(1 << k) — k bitini temizleme
  • n ^ (1 << k) — k bitini değiştirme
  • (n >> k) & 1 — k bitini kontrol etme
# Bit trick cheatsheet — all at once
n = 0b10110100  # 180

print(f'n = {bin(n)} = {n}')
print(f'n & 1       (odd check)         = {n & 1}')          # 0: even
print(f'n & (n-1)   (clear lowest bit)  = {bin(n & (n-1))}')
print(f'n & -n      (isolate lowest bit) = {bin(n & -n)}')
print(f'n | (1<<1)  (set bit 1)          = {bin(n | (1<<1))}')
print(f'n & ~(1<<2) (clear bit 2)        = {bin(n & ~(1<<2))}')
print(f'n ^ (1<<5)  (toggle bit 5)       = {bin(n ^ (1<<5))}')
print(f'(n>>4) & 1  (check bit 4)        = {(n>>4) & 1}')

Ayarlanmış Bitleri Sayma (1 Bitlerinin Sayımı)

Bir tamsayıdaki 1 bitlerinin sayısını bulmaya 1 bitlerinin sayımı denir. Saf yaklaşım, tüm bitleri dolaşır. Brian Kernighan hilesi daha hızlıdır: n &= n - 1 ile en düşük ayarlanmış biti art arda temizleyin ve n sıfır olana kadar yinelemeleri sayın. Her yineleme tam olarak bir 1 bitini kaldırdığı için döngü, 1 bitlerinin sayısı kadar kez çalışır.

Python 3.10 ve sonraki sürümler, sayıyı doğrudan döndüren int.bit_count() işlevini sağlar. Daha eski sürümlerde Kernighan hilesi, elle uygulanan standart yaklaşımdır. Bu teknik, LeetCode'daki 'Hamming Ağırlığı' problemini de çözer.

# Method 1: naive O(log n)
def count_bits_naive(n):
    count = 0
    while n:
        count += n & 1
        n >>= 1
    return count

# Method 2: Brian Kernighan O(k) where k = number of set bits
def count_bits_fast(n):
    count = 0
    while n:
        n &= n - 1   # clear lowest set bit
        count += 1
    return count

# Method 3: Python built-in (3.10+)
# n.bit_count()

for x in [0, 1, 7, 255, 180, 1024]:
    naive = count_bits_naive(x)
    fast  = count_bits_fast(x)
    print(f'{x:4d} ({bin(x):10s}): naive={naive}, fast={fast}')

Python'da Bit İşlemleri: Önemli Noktalar

C/Java'nın aksine Python tamsayıları istenildiği kadar büyüyebilir; 32 bitlik veya 64 bitlik taşma yoktur. Bu nedenle 32 bitlik davranış bekleyen problemleri çözerken sonuçları sabit bir genişliğe kendiniz maskelemeniz gerekir: yalnızca düşük 32 biti korumak için & 0xFFFFFFFF kullanın.

Python'daki NOT işleci ~n, C'de bekleyebileceğiniz bitleri tersine çevrilmiş gösterimi değil, -(n+1) değerini döndürür. 32 bitlik problemler için beklenen 32 bitlik tümleyeni elde etmek üzere ~n & 0xFFFFFFFF kullanın veya 0xFFFFFFFF ^ n hesaplayın. C tarzı bit işlemlerine alışkın birçok aday bu farklılıklar nedeniyle hata yapar.

# Python vs C gotchas
# In C: unsigned 32-bit NOT of 5 = 4294967290
# In Python: ~5 = -6
print(f'Python ~5 = {~5}')              # -6
print(f'32-bit ~5 = {~5 & 0xFFFFFFFF}') # 4294967290

# No integer overflow in Python
big = 1 << 100   # 2^100: huge number, no overflow
print(f'2^100 = {big}')  # works fine

# Right shift on negatives: arithmetic (sign-extending)
print(f'-1 >> 3 = {-1 >> 3}')   # -1 (all ones shifted in)

# Safe 32-bit mask for problems expecting C/Java semantics
MASK32 = 0xFFFFFFFF
result = (5 + 0xFFFFFFFE) & MASK32  # simulates 32-bit overflow
print(f'5 + (-2) in 32-bit = {result}')  # 3

Kaydırma İşleçleri ve Çarpma

Sola ve sağa kaydırma, ikinin kuvvetleriyle çarpmanın veya bölmenin son derece hızlı bir yolunu sağlar. Donanımda bit kaydırmaları tek komutluk işlemlerken çarpma ve bölme birden çok saat çevrimi gerektirir. Python'da tamsayı çarpımı zaten verimlidir; yine de bu ilişkiyi anlamak, bit örüntülerini daha net görmenize yardımcı olur.

Yararlı bir özdeşlik şudur: n'nin 2^k'nin katı olup olmadığını kontrol etmek için (n & (2^k - 1)) == 0 kullanın. 2^k - 1 maskesinin alt k bitinin tamamı 1'dir; bu maskeyle AND işlemi yapmak, 2^k'ye bölündüğündeki kalanı verir. Bu, n % (2^k) ifadesine eşdeğerdir ancak C tabanlı dillerde daha hızlıdır.

# Shift vs arithmetic equivalence
for k in range(1, 5):
    n = 48
    print(f'{n} * 2^{k} = {n * (2**k)} = {n << k} (left shift)')
    print(f'{n} // 2^{k} = {n // (2**k)} = {n >> k} (right shift)')
    print()

# Check divisibility by power of 2
def divisible_by_power_of_2(n, k):
    mask = (1 << k) - 1   # 2^k - 1: lower k bits all 1
    return (n & mask) == 0

for n in [16, 24, 32, 15, 100]:
    print(f'{n} divisible by 4? {divisible_by_power_of_2(n, 2)}')

Kısa Kontrol

Bu dersteki Veri Yapıları ve Algoritmalar — Kodlama Mülakatına Hazırlık kavramlarını anlayıp anlamadığınızı test edin.

Ders Özeti

Bu derste şunları öğrendiniz: AND bitleri maskeler, OR bitleri ayarlar, XOR bitleri değiştirir ve farklılıkları tespit eder, NOT bitleri tersine çevirir (Python'da -(n+1) değerini verir) ve kaydırma işlemleri ikinin kuvvetleriyle çarpar/böler; n & (n-1), en düşük ayarlanmış biti temizler ve ikinin kuvveti kontrolleriyle bit sayımının temelini oluşturur; ayrıca Python'da sabit genişlikte taşma yoktur; bu nedenle 32 bitlik problemler & 0xFFFFFFFF ile açıkça maskeleme gerektirir. Sırada, tek sayı problem ailesini çözmek için XOR'un kendinin tersi olma özelliğini inceleyeceğiz.

Sıkça Sorulan Sorular

“Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar” dersi ücretsiz mi?

Evet — “Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve DSA Interview Prep kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. DSA Interview Prep kursu toplamda 4 dersten oluşur.

“Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar” dersinde ne öğreneceğim?

Altı bit düzeyi işlecin tümünü doğruluk tabloları ve Python örnekleriyle gözden geçirin; sola ve sağa kaydırmaların ikiyle çarpma ve bölmeyle ilişkisini anlayın. DSA Interview Prep ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

DSA Interview Prep öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te DSA Interview Prep, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu DSA Interview Prep dersinde kod yazıp çalıştırabilir miyim?

Evet. Her DSA Interview Prep dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Bit Düzeyi İşleçler: AND, OR, XOR, NOT ve Kaydırmalar
  2. Tek Sayı ve XOR Özellikleri
  3. Bit Maskeleri: Ayarla, Temizle, Değiştir, Denetle
  4. Bitleri Sayma, Eksik Sayı ve Bitleri Ters Çevirme
← DSA Interview Prep Sayfasına Dön