Blog

#কিউ #সার্কুলার কিউ #ডিকিউ #প্রায়োরিটি কিউ #ডাটা স্ট্রাকচার #লিংকড লিস্ট #রিং বাফার #বিএফএস #অ্যালগরিদম #প্রোগ্রামিং শেখা #পাইথন #queue #circular queue #deque #data structure bangla #bfs

কিউ (Queue) ও সার্কুলার কিউঃ যে ডাটা স্ট্রাকচারটা ছাড়া আজকের ইন্টারনেট এক সেকেন্ডও চলত না

2026-09-23 · 34 min read

কিউ (Queue) ও সার্কুলার কিউঃ যে ডাটা স্ট্রাকচারটা ছাড়া আজকের ইন্টারনেট এক সেকেন্ডও চলত না

সকাল ন'টা। মেট্রোরেলের টিকিট কাউন্টারে লম্বা লাইন। আপনি এসে দাঁড়ালেন একদম পেছনে। সামনের জন টিকিট নিয়ে বেরিয়ে গেল, লাইন এক ধাপ এগোলো। আর যদি কেউ পাশ কাটিয়ে সামনে ঢুকে পড়ে? পুরো লাইন একসাথে তাকিয়ে থাকে। অভিনন্দন! আপনি এইমাত্র কিউ (Queue) ডাটা স্ট্রাকচারটা শিখে ফেলেছেন। বাকিটা শুধু ভাষা বদলানো। কিউ হলো FIFO (First In, First Out)। যে আগে এসেছে, সে আগে যাবে। এই এক লাইনের নিয়মের ওপর দাঁড়িয়ে আছে আপনার ব্রাউজারের ইভেন্ট লুপ, ফুডপান্ডার অর্ডার সিস্টেম, WhatsApp-এর মেসেজ ডেলিভারি, এমনকি ChatGPT-কে করা আপনার প্রশ্নটাও একটা কিউতে দাঁড়িয়ে ছিল কয়েক মিলিসেকেন্ড। চলুন, লাইনে দাঁড়িয়ে পড়ি।

কিউ-এর মৌলিক অপারেশন

মাত্র দুটো কাজ, মনে রাখা সহজঃ

অপারেশনকাজটিকিট কাউন্টার অ্যানালজি
Enqueueপেছনে নতুন এলিমেন্ট ঢোকানোনতুন লোক লাইনের শেষে দাঁড়াল
Dequeue (pop)সামনের এলিমেন্ট বের করাসামনের লোক টিকিট নিয়ে চলে গেল
peek / frontসামনে কে আছে দেখা (বের না করে)উঁকি দিয়ে দেখা
isEmpty / sizeখালি কিনা / কতজন আছেলাইন কত লম্বা

ভালো কিউ ইমপ্লিমেন্টেশনের শর্ত একটাই, এই সবগুলো অপারেশন হতে হবে O(1), মানে লাইনে ১০ জন থাকুক বা ১০ লাখ, সময় একই লাগবে। এই "O(1)" শর্তটা মাথায় গেঁথে নিন। নিচের পুরো লেখাটা আসলে এই একটা শর্ত রক্ষা করার গল্প।

প্রথম চেষ্টাঃ অ্যারে দিয়ে কিউ (এবং যে ফাঁদে সবাই পড়ে)

সবচেয়ে সহজ আইডিয়া। একটা অ্যারে নিন, আর দুটো পয়েন্টারঃ

  • head → সামনের এলিমেন্ট কোথায়
  • tail → পেছনের এলিমেন্ট কোথায়

শুরুতে দুটোই -1, কারণ কিউ খালি।

  • Enqueue: tail এক ধাপ বাড়াও, সেখানে নতুন মান বসাও।
  • Dequeue: head এক ধাপ বাড়াও। ব্যস। পুরোনো ঘরটা আর ছুঁয়েও দেখার দরকার নেই।

দুটো জিনিস খেয়াল করুনঃ

১. সব এলিমেন্ট বেরিয়ে গেলে head চলে যায় tail-এর সামনে। এতে ভয়ের কিছু নেই। head > tail মানেই কিউ খালি।

২. কিন্তু এখানেই আসল সমস্যা। head আর tail কেবল সামনেই এগোয়, কখনো পেছনে ফেরে না। Dequeue করার পর সামনের ঘরগুলো খালি হয়ে যায়, অথচ সেই ঘরগুলোতে আর কখনো কিছু রাখা যায় না।

৫ ঘরের অ্যারেতে ৩টা enqueue আর ৩টা dequeue করার পর কিউ পুরো খালি, কিন্তু ব্যবহারযোগ্য ঘর বাকি মাত্র ২টা। ব্যাংক থেকে টাকা তুলে ফেলার পরেও অ্যাকাউন্টের লিমিট কমতে থাকার মতো ব্যাপার। বাস্তবে তাই এভাবে কেউ কিউ বানায় না। সমাধান দুটো, চলুন দুটোই দেখি।

সমাধান ১ঃ লিংকড লিস্ট দিয়ে কিউ

অ্যারের মূল সীমাবদ্ধতা হলো, জায়গাটা আগেই বরাদ্দ করে রাখতে হয় এবং সেটা contiguous। লিংকড লিস্ট এই দুটো শর্তই ভেঙে দেয়। লিংকড লিস্টে তথ্য থাকে নোড নামের আলাদা আলাদা বাক্সে। প্রতিটা নোডে দুটো জিনিস থাকেঃ

  • ডাটাঃ আসল মান
  • next পয়েন্টারঃ পরের নোডটা মেমরির কোথায় আছে, তার ঠিকানা
struct Node {
    int value;
    Node *next;
};

নোডগুলো মেমরিতে ছড়িয়ে-ছিটিয়ে থাকে, শুধু পয়েন্টারের সুতোয় একটার সাথে আরেকটা বাঁধা। গুপ্তধনের ম্যাপের মতো প্রতিটা ক্লু পরের ক্লু কোথায় সেটা বলে দেয়। অ্যারের সাথে পার্থক্যটা পরিষ্কারঃ

অ্যারেলিংকড লিস্ট
i-তম এলিমেন্ট পড়াO(1)O(n) - হেঁটে যেতে হয়
মাঝখানে ইনসার্ট/ডিলিটO(n) - সব সরাতে হয়O(1) - পজিশন জানা থাকলে
সাইজফিক্সডযত খুশি বাড়বে
মেমরিটানা, ক্যাশ-ফ্রেন্ডলিছড়ানো, প্রতি নোডে বাড়তি পয়েন্টার

কিউ বানানোর সময় লাভটা কোথায়?

head পয়েন্টার প্রথম নোডে, tail পয়েন্টার শেষ নোডে রাখুন। তাহলেঃ

  • Enqueue → tail->next-এ নতুন নোড জুড়ে tail সরিয়ে দিন। O(1)
  • Dequeue → head-কে পরের নোডে সরিয়ে পুরোনো নোডটা delete/free করে দিন। O(1), আর মেমরিটাও ফেরত পাওয়া গেল

সাইজ আগে থেকে ঠিক করার দরকার নেই, এক বিন্দু মেমরিও নষ্ট হয় না।

দুটো ক্লাসিক ভুলঃ (১) delete করতে ভুলে গিয়ে মেমরি লিক করা, (২) শেষ নোডটা dequeue করার পর tail-কে NULL না করা।

লিংকড লিস্টের একটা সীমাবদ্ধতাও আছেঃ নোডগুলো মেমরিতে ছড়ানো থাকায় CPU ক্যাশ কাজে লাগে না, আর প্রতি নোডে পয়েন্টারের জন্য বাড়তি ৮ বাইট খরচ হয়। পারফরম্যান্স-ক্রিটিক্যাল কোডে তাই পরের সমাধানটাই জেতে।

সমাধান ২ঃ সার্কুলার কিউ - অ্যারেকে গোল করে জোড়া লাগান

ফিক্সড সাইজের অ্যারে রেখেও মেমরি নষ্ট না করার উপায় আছে। আইডিয়াটা দারুণ সরলঃ অ্যারের শেষ ঘরের পরে আবার প্রথম ঘরে ফিরে আসুন। সোজা লাইনটাকে গোল করে জুড়ে দিন, ঘড়ির কাঁটার মতো। ১১টার পরে ১২টা, তারপর আবার ১টা। ঘড়ি কখনো "জায়গা শেষ" বলে না। সার্কুলার কিউও বলে না।

পুরো জাদুটা একটাই অপারেটর মডুলাস (%)-এঃ

tail = (tail + 1) % capacity
head = (head + 1) % capacity

capacity = 5 হলে tail 4-এ থাকা অবস্থায় (4 + 1) % 5 = 0, নিজে থেকেই শুরুতে ফিরে এলো। মজার ব্যাপার, সার্কুলার কিউতে শুরুর পজিশন 0 হতেই হবে এমন কোনো নিয়ম নেই। যেকোনো ইনডেক্স থেকে শুরু করা যায়, নিচের কোডে যেমন আমরা 2 থেকে শুরু করেছি।

"কিউ ভরে গেছে", বুঝব কী করে?

এটাই সার্কুলার কিউয়ের সবচেয়ে সূক্ষ্ম অংশ। উত্তরটা হলোঃ tail-এর ঠিক পরের ঘরটাই যদি head হয়, তাহলে কিউ ফুল।

(tail + 1) % capacity == head   →   কিউ ফুল

কিউ ফুল অবস্থায় নতুন এলিমেন্ট এলে দুটো আচরণের যেকোনো একটা বেছে নিতে পারেনঃ

  1. এরর দিন ঃ "জায়গা নেই, পরে আসুন।" (সাধারণ সার্কুলার কিউ)
  2. সবচেয়ে পুরোনো এলিমেন্টটা ফেলে দিয়ে নতুনটা রাখুন ঃ একে বলে সার্কুলার বাফার বা রিং বাফার

দুই নম্বরটা মোটেও কোনো কোণায় পড়ে থাকা কৌশল নয়। আপনার ফোনের অডিও ড্রাইভার, গেমের ইনপুট বাফার, সার্ভারের লগ রোটেশন, নেটওয়ার্ক কার্ডের প্যাকেট রিসিভ বাফার সবই রিং বাফার। কারণটা সুন্দরঃ সবচেয়ে সাম্প্রতিক N টা জিনিসই আসলে দরকার, পুরোনোগুলো এমনিতেই অপ্রাসঙ্গিক।

সার্কুলার কিউয়ের পূর্ণাঙ্গ কোড (Python 3)

class CircularQueue:
    def __init__(self, capacity, starting_point=0):
        self.capacity = capacity
        self.data = [None] * capacity
        self.start = starting_point % capacity
        self.head = -1          # -1 মানে কিউ খালি
        self.tail = -1

    def is_empty(self):
        return self.head == -1

    def is_full(self):
        return not self.is_empty() and (self.tail + 1) % self.capacity == self.head

    def enqueue(self, value):
        if self.is_full():
            raise OverflowError("কিউ ভরে গেছে")
        if self.is_empty():
            self.head = self.tail = self.start
        else:
            self.tail = (self.tail + 1) % self.capacity
        self.data[self.tail] = value

    def dequeue(self):
        if self.is_empty():
            raise IndexError("কিউ খালি")
        value = self.data[self.head]
        self.data[self.head] = None
        if self.head == self.tail:          # শেষ এলিমেন্টটা বের হয়ে গেল
            self.head = self.tail = -1
        else:
            self.head = (self.head + 1) % self.capacity
        return value

    def peek(self):
        if self.is_empty():
            raise IndexError("কিউ খালি")
        return self.data[self.head]
q = CircularQueue(capacity=5, starting_point=2)
for x in (10, 20, 30):
    q.enqueue(x)
print(q.dequeue(), q.dequeue())   # 10 20
print(q.peek())                   # 30

চার লাইনের is_full(), চার লাইনের মডুলাস, আর মেমরি অপচয় শূন্য। এটাই প্রকৌশলের সৌন্দর্য।

ইন্টারভিউ টিপ: is_full()-এ not self.is_empty() শর্তটা কেন লাগল? কারণ কিউ খালি থাকলে head == -1, আর (tail + 1) % capacity তখন ভুলভাবে "ফুল" বলে দিতে পারে। এই এজ কেসটাই সবচেয়ে বেশি মিস হয়।

ডাবল এন্ডেড কিউ (Deque): দুই দিকেই দরজা

সাধারণ কিউতে একদিক দিয়ে ঢোকা, আরেকদিক দিয়ে বের হওয়া। ডিকিউ (Deque)-তে দুই প্রান্ত দিয়েই ঢোকা যায়, দুই প্রান্ত দিয়েই বেরোনো যায়। কিউ আর স্ট্যাক, দুটোরই ক্ষমতা এক প্যাকেজে। দেখে মনে হতে পারে অতিরিক্ত বিলাসিতা। কিন্তু ডিকিউ একটা ক্লাসিক সমস্যাকে অসম্ভব সুন্দরভাবে সমাধান করেঃ

স্লাইডিং উইন্ডো মিনিমাম

সমস্যাঃ n সংখ্যার একটা অ্যারেতে প্রতিটা পরপর m-সাইজের উইন্ডোর সবচেয়ে ছোট সংখ্যাটা বের করুন। সহজ সমাধানঃ প্রতিটা উইন্ডো আলাদা করে ঘুরে দেখা, O(n×m)। n = 10⁶ হলে কম্পিউটার হাল ছেড়ে দেবে। ডিকিউ দিয়ে সমাধানের মূল চাবিকাঠি এই একটা বাক্যঃ নতুন একটা সংখ্যা ডিকিউতে ঢোকানোর আগে, ডিকিউয়ের পেছনে থাকা তার চেয়ে বড় সব সংখ্যা বের করে ফেলুন। কেন? ধরুন উইন্ডোতে আগে থেকেই 7 আছে, আর এখন ঢুকছে 3। 3 যেহেতু 7-এর চেয়ে ছোট এবং নতুন (মানে বেশিদিন টিকবে), ভবিষ্যতে কোনো উইন্ডোতেই 7 আর কখনো মিনিমাম হতে পারবে না। 7 এখন নিছক ব্যালাস্ট, ফেলে দিন। এভাবে ডিকিউটা সবসময় সাজানো (monotonic) থাকে, আর সামনের এলিমেন্টটাই বর্তমান উইন্ডোর মিনিমাম। প্রতিটা সংখ্যা জীবনে সর্বোচ্চ একবার ঢোকে আর একবার বের হয়। তাই মোট জটিলতা O(n)। সেগমেন্ট ট্রি দিয়ে করলে লাগত O(n log n); ডিকিউ সেটাকেও হারিয়ে দেয়।

from collections import deque

def sliding_window_minimum(arr, m):
    dq, result = deque(), []      # dq-তে ইনডেক্স রাখছি, মান নয়
    for i, value in enumerate(arr):
        while dq and arr[dq[-1]] >= value:   # বড়গুলো পেছন থেকে ছাঁটাই
            dq.pop()
        dq.append(i)
        if dq[0] <= i - m:                   # উইন্ডোর বাইরে চলে গেছে
            dq.popleft()
        if i >= m - 1:
            result.append(arr[dq[0]])        # সামনের জনই মিনিমাম
    return result

print(sliding_window_minimum([5, 3, 8, 2, 9, 1, 4], 3))
# [3, 2, 2, 1, 1]

স্টক মার্কেটের মুভিং ইন্ডিকেটর, সার্ভারের রেট লিমিটার, রিয়েল-টাইম সেন্সর ডাটার অ্যানোমালি ডিটেকশন সবখানে এই একই প্যাটার্ন।

প্রায়োরিটি কিউঃ যেখানে লাইন ভাঙা বৈধ

প্রায়োরিটি কিউতে প্রতিটা এলিমেন্টের একটা প্রায়োরিটি থাকে। pop করার সময় যে আগে এসেছে সে নয়, যার প্রায়োরিটি সবচেয়ে বেশি, সে আগে বের হয়। হাসপাতালের ইমার্জেন্সি বিভাগ ভাবুন। সর্দি-জ্বরের রোগী আগে এসেছে বলেই হার্ট অ্যাটাকের রোগীকে অপেক্ষা করতে হয় না। এখানে লাইন ভাঙাটাই নিয়ম। প্রায়োরিটি কিউ দক্ষভাবে বানাতে দরকার হিপ (Heap) ডাটা স্ট্রাকচার। যেখানে insert আর extract-min দুটোই O(log n)। হিপ নিয়ে বিস্তারিত আরেকদিন, আপাতত জেনে রাখুন এটা ছাড়া নিচের কোনোটাই চলে নাঃ

  • ডাইকস্ট্রা অ্যালগরিদম ঃ ওজনযুক্ত গ্রাফে সবচেয়ে ছোট পথ (Google Maps-এর মূল ভিত্তি)
  • অপারেটিং সিস্টেমের টাস্ক শিডিউলার ঃ কোন প্রসেস এখন CPU পাবে
  • A* পাথফাইন্ডিং ঃ গেমের NPC কীভাবে আপনাকে খুঁজে বের করে
  • হাফম্যান কোডিং ঃ ফাইল কমপ্রেশনের মূল কৌশল

কিউয়ের সবচেয়ে বিখ্যাত ব্যবহারঃ ব্রেডথ ফার্স্ট সার্চ (BFS)

প্রোগ্রামিং কনটেস্টে কিউয়ের সবচেয়ে কমন ব্যবহার হয় BFS-এ। ওজনবিহীন গ্রাফে (যেখানে প্রতিটা এজের খরচ সমান) দুই নোডের মধ্যে সবচেয়ে ছোট পথ বের করার অ্যালগরিদম।

ধারণাটা পুকুরে ঢিল ছোড়ার মতো। ঢেউ বৃত্তাকারে ছড়ায়, কাছেরটা আগে ভেজে, দূরেরটা পরে।

১. সোর্স নোডের লেভেল 0। তাকে কিউতে ঢোকান। ২. কিউ থেকে সামনের নোড u বের করুন। ৩. u-এর যেসব প্রতিবেশী এখনো ভিজিট করা হয়নি, তাদের distance[v] = distance[u] + 1 বসিয়ে কিউতে ঢোকান। ৪. কিউ খালি না হওয়া পর্যন্ত ২–৩ চালান।

প্রতিটা নোড ঠিক একবারই ভিজিট হয়, এই শর্তটাই BFS-এর প্রাণ। কিউ এখানে কেন অপরিহার্য? কারণ FIFO স্বভাবের জন্য লেভেল 1-এর সব নোড কিউতে লেভেল 2-এর নোডদের আগে থাকে। ফলে অ্যালগরিদম নিজে থেকেই কাছের নোডগুলো আগে প্রসেস করে। আর এই কারণেই একটা নোডে পৌঁছানোর সময় যে দূরত্বটা পাওয়া যায়, সেটাই সবচেয়ে ছোট দূরত্ব। স্ট্যাক ব্যবহার করলে এটা DFS হয়ে যেত, আর শর্টেস্ট পাথের নিশ্চয়তাটা হারিয়ে যেত। জটিলতা O(V + E), প্রতিটা নোড আর প্রতিটা এজ একবার করে দেখা হয়। ২D গ্রিডেও একই কৌশল খাটে, শুধু নোড হিসেবে (row, col) জোড়া ব্যবহার করতে হয়। মেইজ সলভার, ফ্লাড ফিল, গেমের ম্যাপে শর্টেস্ট পাথ সবই এভাবে।

বর্তমানে কিউঃ

ডাটা স্ট্রাকচারটা ১৯৫০-এর দশকের, কিন্তু আজকের সিস্টেম ডিজাইনে এর গুরুত্ব আগের চেয়ে অনেক বেশিঃ

মেসেজ কিউ ও ইভেন্ট স্ট্রিমিংঃ Kafka, RabbitMQ, Amazon SQS, Redis Streams। একটা অর্ডার প্লেস হওয়ামাত্র ইনভয়েস, নোটিফিকেশন, ডেলিভারি অ্যাসাইনমেন্ট সব আলাদা কিউতে চলে যায়। API রেসপন্স সাথে সাথে ফেরত আসে, বাকি কাজ পেছনে চলতে থাকে। Kafka-র প্রতিটা পার্টিশন আসলে ডিস্কে লেখা একটা append-only লগ। ধারণাগতভাবে আমাদের রিং বাফারেরই বড় ভাই, যেখানে পুরোনো ডাটা retention পিরিয়ড শেষে মুছে যায়।

জাভাস্ক্রিপ্টের ইভেন্ট লুপঃ ব্রাউজারে দুটো কিউ আছে। মাইক্রোটাস্ক কিউ (Promise) আর ম্যাক্রোটাস্ক কিউ (setTimeout, ক্লিক ইভেন্ট)। মাইক্রোটাস্ক কিউ সবসময় আগে খালি হয়। setTimeout(fn, 0) কেন Promise.resolve().then(fn)-এর পরে চলে। React-এর কনকারেন্ট রেন্ডারারও ভেতরে প্রায়োরিটি কিউ ব্যবহার করে ঠিক করে কোন আপডেট আগে রেন্ডার হবে।

LLM ইনফারেন্স সার্ভিংঃ এটাই সবচেয়ে সমসাময়িক উদাহরণ। vLLM বা TensorRT-LLM-এর মতো সার্ভিং ইঞ্জিন continuous batching ব্যবহার করে। আসা রিকোয়েস্টগুলো একটা কিউতে জমা হয়, কোনো একটা রিকোয়েস্ট শেষ হলেই তার জায়গায় কিউ থেকে নতুন রিকোয়েস্ট ব্যাচে ঢুকে যায়। GPU কখনো অলস বসে থাকে না।

রেট লিমিটিংঃ sliding window log অ্যালগরিদম একটা ডিকিউতে টাইমস্ট্যাম্প রাখে, উইন্ডোর বাইরের পুরোনো এন্ট্রি সামনে থেকে ফেলে দেয়। হ্যাঁ, ঠিক উপরের স্লাইডিং উইন্ডো মিনিমামের চাচাতো ভাই।

ব্যাকপ্রেশার ও অটোস্কেলিংঃ আধুনিক ক্লাউড সিস্টেম CPU দেখে স্কেল করে না, কিউ ডেপথ দেখে স্কেল করে। লাইন লম্বা হলে আরও কাউন্টার খোলো। এর পেছনে আছে Little's Law: L = λW, গড় কিউ দৈর্ঘ্য = আগমনের হার × গড় অপেক্ষার সময়। ক্যাপাসিটি প্ল্যানিংয়ের এক নম্বর সূত্র, আর এটা জানা থাকলে "কত রেপ্লিকা লাগবে" প্রশ্নের উত্তরটা আন্দাজ নয়, হিসাব হয়ে যায়।

প্রোডাকশনে কী ব্যবহার করবেন

প্রায় প্রতিটা প্রোগ্রামিং ভাষাতেই তৈরি কিউ আছে। শেখার সময় নিজে হাতে ইমপ্লিমেন্ট করুন, কাজের সময় লাইব্রেরি ব্যবহার করুনঃ

ভাষাযা ব্যবহার করবেন
C++std::queue, std::deque, std::priority_queue
Pythoncollections.deque (O(1) দুই প্রান্তেই), heapq, থ্রেডের জন্য queue.Queue
JavaArrayDeque (LinkedList-এর চেয়ে দ্রুত), PriorityQueue
JavaScriptarray.shift() O(n) বড় কিউতে ব্যবহার করবেন না, দুই-পয়েন্টার বা লিংকড লিস্ট বানান
Goবাফার্ড চ্যানেল (make(chan T, n)) ভেতরে রিং বাফারই
RustVecDeque রিং বাফারের ওপর তৈরি
C#Queue<T>, PriorityQueue<TElement, TPriority>

হাতে-কলমে অনুশীলন

পড়ে বোঝা আর কোড করে বোঝা এক জিনিস নয়। ক্রমানুসারে চেষ্টা করুনঃ

  1. লিংকড লিস্ট দিয়ে কিউ ঃ enqueue, dequeue, peek, size
  2. সার্কুলার কিউ ঃ উপরের কোডটা না দেখে লিখুন, খালি ও ফুল দুটো এজ কেসই হ্যান্ডল করুন
  3. দুটো স্ট্যাক দিয়ে কিউ (LeetCode 232) ক্লাসিক ইন্টারভিউ প্রশ্ন
  4. Sliding Window Maximum (LeetCode 239) মনোটোনিক ডিকিউ
  5. BFS দিয়ে মেইজ সলভার ঃ ২D গ্রিডে শর্টেস্ট পাথ
  6. রিং বাফার লগার ঃ সর্বশেষ ১০০০টা লগ রাখুন, পুরোনোগুলো আপনাআপনি মুছে যাবে

শেষ কথা

কিউ শেখার আসল মজাটা হলো, এটা শেখার পর আপনি আর আগের মতো করে সিস্টেম দেখবেন না। প্রিন্টারের জবের লাইন, লিফটের রিকোয়েস্ট, ফেসবুক লাইভের কমেন্ট স্ট্রিম, অনলাইন গেমের ম্যাচমেকিং, এমনকি ট্রাফিক সিগন্যাল সবখানেই আপনি একই প্যাটার্ন দেখতে পাবেন। পুরো জিনিসটার মূল কথা মাত্র চার শব্দঃ যে আগে আসে, সে আগে যায়। এবার এডিটর খুলুন। নিজে একটা কিউ লিখে ফেলুন। লাইব্রেরি পরে, আগে ভেতরটা বুঝুন। হ্যাপি কোডিং!