Coding Interview Prep · บทเรียน

ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต

บทเรียน 1 จาก 413 ขั้นตอน

ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต เป็นบทเรียน Coding Interview Prep ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Coding Interview Prep และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Coding Interview Prep มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดการจัดการบิตจึงสำคัญ

การจัดการบิตช่วยให้คุณทำงานโดยตรงกับการแทนค่าจำนวนเต็มในรูปเลขฐานสองได้ ปัญหาหลายอย่างที่ดูซับซ้อนจะกลายเป็นเรื่องง่ายด้วยเทคนิคระดับบิตที่เหมาะสม เช่น การค้นหาเลขที่หายไปในเวลา O(n) และใช้พื้นที่ O(1) การสลับค่าตัวแปรโดยไม่ใช้ตัวแปรชั่วคราว หรือการเข้ารหัสเซตย่อยอย่างกะทัดรัด ผู้สัมภาษณ์ใช้ปัญหาเหล่านี้เพื่อทดสอบความเข้าใจการทำงานระดับล่างและความคิดสร้างสรรค์

จำนวนเต็มของไพทอนมีความละเอียดได้โดยไม่จำกัด กล่าวคือมีขนาดใหญ่ได้เท่าที่หน่วยความจำรองรับ แต่การดำเนินการกับบิตจะใช้ความหมายแบบส่วนเติมเต็มสองตามมาตรฐานในระดับฮาร์ดแวร์เสมอ ตัวดำเนินการทั้งหกทำงานกับการแทนค่าจำนวนเต็มในรูปเลขฐานสองทีละบิต

# 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: การใช้มาสก์บิต

ตัวดำเนินการ AND (&)จะแสดงผลเป็น 1 ก็ต่อเมื่อบิตข้อมูลเข้าทั้งสองบิตเป็น 1 การใช้งานหลักคือการใช้มาสก์: เลือกบิตบางบิตของตัวเลขและกำหนดบิตอื่นทั้งหมดให้เป็นศูนย์ หากต้องการตรวจสอบว่าบิต k ถูกตั้งค่าไว้ในตัวเลข n หรือไม่ ให้คำนวณ n & (1 << k) หากผลลัพธ์ไม่ใช่ศูนย์ แสดงว่าบิต k มีค่าเป็น 1

AND ยังใช้สำหรับล้างบิต 1 ที่ต่ำที่สุดได้ด้วย: n & (n - 1) จะล้างบิต 1 ที่อยู่ขวาสุด วิธีนี้ใช้ในการนับบิต 1 อย่างมีประสิทธิภาพ และตรวจสอบว่าตัวเลขเป็นกำลังของสองหรือไม่ (กำลังของสองมีบิต 1 เพียงหนึ่งบิต ดังนั้น n & (n-1) == 0)

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: การตั้งค่าบิต

ตัวดำเนินการ OR (|)จะแสดงผลเป็น 1 หากบิตข้อมูลเข้าอย่างน้อยหนึ่งบิตเป็น 1 การใช้งานหลักคือการตั้งค่าบิตที่ระบุให้เป็น 1 โดยไม่กระทบบิตอื่น หากต้องการตั้งค่าบิต k ในตัวเลข n ให้ใช้ n | (1 << k) เลข 1 ที่เลื่อนไปยังตำแหน่ง k จะเปิดบิตนั้น ส่วนบิตอื่นทั้งหมดจะไม่เปลี่ยนแปลง เพราะการทำ OR กับ 0 จะคงค่าเดิมไว้

OR ยังใช้สำหรับการรวมแฟล็กด้วย หากแทนแฟล็กคุณลักษณะเป็นบิตแต่ละบิต คุณสามารถเปิดใช้แฟล็กหลายตัวด้วย OR ตัวอย่างเช่น READ | WRITE | EXECUTE จะรวมบิตสิทธิ์สามบิตไว้ในจำนวนเต็มหนึ่งค่า

# 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: การสลับและความแตกต่าง

ตัวดำเนินการ XOR (^)จะแสดงผลเป็น 1 เมื่อบิตข้อมูลเข้าแตกต่างกัน XOR มีสมบัติทางพีชคณิตที่ทรงพลังสามประการ ได้แก่ a ^ a = 0 (ข้อมูลเข้าที่เหมือนกันจะหักล้างกัน) a ^ 0 = a (ศูนย์เป็นสมาชิกเอกลักษณ์) และ XOR มีสมบัติสลับที่และสมบัติการเปลี่ยนหมู่ สมบัติเหล่านี้ทำให้ XOR เป็นเครื่องมือหลักสำหรับค้นหาสมาชิกที่ไม่ซ้ำ

XOR ยังใช้สำหรับสลับบิตที่ระบุได้ด้วย: n ^ (1 << k) จะกลับค่าบิต k โดยไม่เปลี่ยนบิตอื่น หากบิต k เป็น 0 บิตนั้นจะกลายเป็น 1 หากเป็น 1 จะกลายเป็น 0

# 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 และส่วนเติมเต็มสอง

ตัวดำเนินการ NOT (~)จะกลับค่าบิตทั้งหมด ในไพทอน ~n มีค่าเท่ากับ -(n+1) เนื่องจากการแทนค่าแบบส่วนเติมเต็มสอง เรื่องนี้ทำให้หลายคนประหลาดใจ: ~5 = -6 ไม่ใช่ 0b11111010 อย่างที่อาจคาดเดาแบบตรงไปตรงมา จำนวนเต็มของไพทอนมีความละเอียดไม่จำกัด ดังนั้นการกลับค่าบิตทั้งหมดของจำนวนบวกจึงให้ผลเป็นจำนวนลบตามส่วนเติมเต็มสอง

ในทางปฏิบัติ คุณแทบไม่ใช้ ~ เพียงอย่างเดียวในการจัดการบิตด้วยไพทอน แต่จะใช้ร่วมกับ AND เพื่อล้างบิตที่ระบุ หรือคำนวณ ~n & mask โดยให้ mask จำกัดความกว้างไว้ที่จำนวนบิตที่กำหนด (เช่น & 0xFFFFFFFF สำหรับ 32 บิต)

# 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

การเลื่อนซ้าย: คูณด้วยกำลังของสอง

ตัวดำเนินการเลื่อนซ้าย (<<)จะเลื่อนบิตทั้งหมดไปทางซ้าย k ตำแหน่ง และเติมตำแหน่งด้านขวาที่ว่างด้วยศูนย์ การดำเนินการนี้เทียบเท่ากับการคูณด้วย 2^k การเลื่อนซ้าย 1 ตำแหน่งจะเพิ่มค่าเป็นสองเท่า ส่วนการเลื่อนซ้าย k ตำแหน่งจะคูณค่าด้วย 2^k

ในปัญหาสัมภาษณ์ การเลื่อนซ้ายมักใช้เพื่อสร้างมาสก์บิต: 1 << k จะสร้างตัวเลขที่มีเพียงบิต k เท่านั้นที่ถูกตั้งค่าไว้ นี่คือพื้นฐานของการดำเนินการจัดการบิตทั้งหมด ไม่ว่าจะเป็นการตั้งค่า การล้าง การสลับ หรือการตรวจสอบบิตแต่ละบิต ล้วนเริ่มต้นด้วย 1 << k

# 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

การเลื่อนขวา: หารด้วยกำลังของสอง

ตัวดำเนินการเลื่อนขวา (>>)จะเลื่อนบิตทั้งหมดไปทางขวา k ตำแหน่ง และทิ้งบิต k บิตที่อยู่ขวาสุด การดำเนินการนี้เทียบเท่ากับการหารจำนวนเต็มด้วย 2^k การเลื่อนขวาของไพทอนเป็นแบบเชิงเลขคณิตเสมอ โดยบิตด้านซ้ายสุดจะเติมด้วยบิตเครื่องหมาย (0 สำหรับจำนวนบวก และ 1 สำหรับจำนวนลบ)

เทคนิคที่พบบ่อยในการสัมภาษณ์คือ การดึงบิต k จากตัวเลข n ด้วย (n >> k) & 1 วิธีนี้จะเลื่อนบิต k ลงมายังตำแหน่ง 0 แล้วใช้มาสก์ตัดบิตอื่นทั้งหมดออก เป็นวิธีที่สะอาดที่สุดในการตรวจสอบบิตใดบิตหนึ่งโดยไม่ต้องคำนวณและเปรียบเทียบมาสก์เต็มรูปแบบ

# 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)

สรุปเทคนิคการจัดการบิตที่ใช้ได้จริง

ต่อไปนี้คือรูปแบบการเขียนสำหรับการจัดการบิตที่พบบ่อยที่สุดซึ่งคุณจะพบในการสัมภาษณ์ ควรจดจำรูปแบบเหล่านี้ไว้ เพราะปรากฏซ้ำแล้วซ้ำอีกในปัญหาหลายสิบข้อ:

n & 1 — ตรวจสอบว่า n เป็นเลขคี่หรือไม่
n & (n-1) — ล้างบิต 1 ที่ต่ำที่สุด
n & -n — แยกบิต 1 ที่ต่ำที่สุดออกมา
n | (1 << k) — ตั้งค่าบิต k
n & ~(1 << k) — ล้างบิต k
n ^ (1 << k) — สลับบิต k
(n >> k) & 1 — ตรวจสอบบิต k

# 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}')

การนับบิตที่เป็น 1 (ป๊อปเคานต์)

การนับจำนวนบิต 1 ในจำนวนเต็มเรียกว่าการนับจำนวนบิต (ป๊อปเคานต์) วิธีพื้นฐานจะวนตรวจสอบบิตทั้งหมด ส่วนเทคนิค Brian Kernighanทำได้เร็วกว่า โดยล้างบิต 1 ที่ต่ำที่สุดซ้ำ ๆ ด้วย n &= n - 1 และนับจำนวนรอบจนกว่า n จะเป็น 0 การวนซ้ำแต่ละรอบจะลบบิต 1 ออกทีละหนึ่งบิตพอดี ดังนั้นลูปจึงทำงานเป็นจำนวนรอบเท่ากับจำนวนบิต 1

ไพทอน 3.10 ขึ้นไปมี int.bit_count() ซึ่งคืนค่าจำนวนบิตให้โดยตรง สำหรับรุ่นเก่ากว่านั้น เทคนิคของ Kernighan เป็นวิธีมาตรฐานสำหรับเขียนเอง เทคนิคนี้ยังใช้แก้ปัญหา “น้ำหนักแฮมมิง” บน LeetCode ได้ด้วย

# 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}')

ข้อควรระวังสำคัญในการจัดการบิตด้วยไพทอน

ต่างจากภาษาซี/Java จำนวนเต็มของไพทอนมีขนาดใหญ่ได้โดยไม่จำกัด จึงไม่มีค่าล้นแบบ 32 บิตหรือ 64 บิต ซึ่งหมายความว่า คุณต้องใช้มาสก์กับผลลัพธ์ด้วยตนเองให้มีความกว้างคงที่ เมื่อแก้ปัญหาที่คาดหวังพฤติกรรมแบบ 32 บิต โดยใช้ & 0xFFFFFFFF เพื่อเก็บไว้เฉพาะ 32 บิตล่าง

ตัวดำเนินการ NOT ~n ในไพทอนจะคืนค่า -(n+1) ไม่ใช่ค่าที่กลับบิตแล้วอย่างที่คุณอาจคาดหวังจากภาษาซี สำหรับปัญหาแบบ 32 บิต ให้ใช้ ~n & 0xFFFFFFFF หรือคำนวณ 0xFFFFFFFF ^ n เพื่อให้ได้ส่วนเติมเต็มแบบ 32 บิตตามที่คาดไว้ ความแตกต่างเหล่านี้ทำให้ผู้สมัครจำนวนมากที่คุ้นเคยกับการจัดการบิตรูปแบบภาษาซีสับสน

# 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

ตัวดำเนินการเลื่อนและการคูณ

การเลื่อนซ้ายและการเลื่อนขวาเป็นวิธีที่รวดเร็วมากสำหรับการคูณหรือหารด้วยกำลังของสอง ในฮาร์ดแวร์ การเลื่อนบิตเป็นการดำเนินการด้วยคำสั่งเดียว ขณะที่การคูณและการหารต้องใช้หลายรอบการทำงาน ในไพทอน การคูณจำนวนเต็มมีประสิทธิภาพอยู่แล้ว แต่การเข้าใจความสัมพันธ์นี้จะช่วยให้คุณมองเห็นรูปแบบของบิตได้ชัดเจนขึ้น

เอกลักษณ์ที่มีประโยชน์คือ หากต้องการตรวจสอบว่า n เป็นพหุคูณของ 2^k หรือไม่ ให้ใช้ (n & (2^k - 1)) == 0 มาสก์ 2^k - 1 มีบิตล่าง k บิตเป็น 1 ทั้งหมด การทำ AND กับมาสก์นี้จะให้เศษเหลือจากการหารด้วย 2^k ซึ่งเทียบเท่ากับ n % (2^k) แต่เร็วกว่าในภาษาที่ใช้ภาษาซีเป็นพื้นฐาน

# 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)}')

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจแนวคิดเรื่องโครงสร้างข้อมูลและอัลกอริทึม — การเตรียมตัวสัมภาษณ์การเขียนโปรแกรมจากบทเรียนนี้

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า AND ใช้มาสก์บิต OR ใช้ตั้งค่าบิต XOR ใช้สลับบิตและตรวจจับความแตกต่าง NOT ใช้กลับค่าบิต (และให้ผลเป็น -(n+1) ในไพทอน) ส่วนการเลื่อนใช้คูณหรือหารด้วยกำลังของสอง n & (n-1) ใช้ล้างบิต 1 ที่ต่ำที่สุด และเป็นพื้นฐานของการตรวจสอบกำลังของสองและการนับบิต และ ไพทอนไม่มีค่าล้นที่มีความกว้างตายตัว ดังนั้นปัญหาแบบ 32 บิตจึงต้องใช้มาสก์อย่างชัดเจนด้วย & 0xFFFFFFFF บทถัดไปเราจะสำรวจคุณสมบัติการเป็นอินเวอร์สตัวเองของ XOR เพื่อแก้ปัญหาตระกูลเลขเดี่ยว

เริ่มต้นได้ฟรี

เรียนรู้ Coding Interview Prep ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 90
บทเรียน: 360

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Coding Interview Prep ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Coding Interview Prep มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต”

ทบทวนตัวดำเนินการระดับบิตทั้งหกชนิดด้วยตารางค่าความจริงและตัวอย่าง Python พร้อมทำความเข้าใจว่าการเลื่อนซ้ายและขวาเกี่ยวข้องกับการคูณและหารด้วยสองอย่างไร คุณปฏิบัติ Coding Interview Prep ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Coding Interview Prep หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Coding Interview Prep บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Coding Interview Prep นี้ได้ไหม

ได้ บทเรียน Coding Interview Prep ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

ตัวดำเนินการระดับบิต: AND, OR, XOR, NOT และการเลื่อนบิต
จำนวนเดี่ยวและคุณสมบัติของ XOR
บิตมาสก์: ตั้งค่า ล้าง สลับ และตรวจสอบ
การนับบิต จำนวนที่หายไป และการกลับบิต

← กลับไปที่ Coding Interview Prep