সংখ্যা পদ্ধতি — binary, octal, hexadecimal আর রূপান্তর

১ · স্থানীয় মানের সংখ্যা পদ্ধতি — একটিই সূত্র

বাজারের ক্যালকুলেটরে ২৩৪৭ লিখলে আমরা কেউ ভাবি না এর মানে কী। কিন্তু ভেতরে একটি নিয়ম আছে: শেষ অঙ্ক ৭ মানে সাতটি এক, তার বাঁয়ের ৪ মানে চারটি দশ, তারপর তিনটি একশো, দুটি হাজার। অঙ্কটি কোন ঘরে বসেছে, তার ওপর নির্ভর করে তার মান। এই ধরনের লেখাকে বলে positional number system বা স্থানীয় মানের সংখ্যা পদ্ধতি।

যেকোনো ভিত্তি (radix বা base) r-এর জন্য নিয়মটি একই। অঙ্ক হতে পারে শুধু 0, 1, …, r−1 — মোট r টি চিহ্ন। ডান দিক থেকে ঘরগুলোর ওজন r⁰, r¹, r², … আর দশমিক বিন্দুর ডানে r⁻¹, r⁻², …

এই একটি সূত্র থেকেই সব আসে। r = ১০ হলে আমাদের চেনা দশমিক। r = ২ হলে binary — অঙ্ক শুধু 0 আর 1, যাকে বলে bit (binary digit). r = ৮ হলে octal, অঙ্ক 0–7. r = ১৬ হলে hexadecimal বা সংক্ষেপে hex — এখানে ১০টি অঙ্কে কুলায় না, তাই ১০ থেকে ১৫-এর জন্য A, B, C, D, E, F ধার করা হয়।

সবচেয়ে ডানের বিটের ওজন সবচেয়ে কম — LSB (least significant bit); সবচেয়ে বাঁয়ের বিট MSB (most significant bit). বিন্দুর ডানে ঋণাত্মক ঘাত: (0.101)₂ = ১/২ + ১/৮ = ০.৬২৫।

কোড আর বইয়ে ভিত্তি বোঝানোর কয়েকটি রীতি আছে। গণিতে নিচে ছোট করে লেখা হয়: (9C)₁₆. C, JavaScript, Python-এ hex লেখা হয় 0x9C, binary 0b10011100. C-তে শুরুতে একটি 0 দিলে octal — 0234 মানে দশমিক ১৫৬, এটি একটি পুরোনো ফাঁদ যা নিচে কোড চালিয়ে দেখবেন। Assembly-তে অনেক সময় শেষে h লেখা হয় (9Ch), আর Unicode-এ U+0985.

২ · কেন binary, আর octal-hex কেন তার সংক্ষিপ্ত রূপ

মানুষ দশ দিয়ে গোনে কারণ আমাদের দশটি আঙুল। কম্পিউটার দুই দিয়ে গোনে, কারণ তার “আঙুল” হলো transistor — আর একটি transistor-কে নির্ভরযোগ্যভাবে দুটি অবস্থায় রাখা সবচেয়ে সহজ: চালু অথবা বন্ধ, উঁচু ভোল্টেজ অথবা নিচু ভোল্টেজ। ঘরের সুইচবোর্ডের সুইচের মতো — মাঝামাঝি কোনো অবস্থা নেই, তাই ভুল বোঝারও সুযোগ কম।

কিন্তু আসল কারণ আরও গভীর: শব্দ বা noise. তারের ভোল্টেজ কখনো ঠিক নিখুঁত থাকে না — পাশের তারের প্রভাব, তাপমাত্রা, বিদ্যুতের ওঠানামা সব মিলিয়ে একটু কাঁপে। দুটি মাত্র স্তর থাকলে মাঝখানে বড় একটি নিরাপদ ফাঁক রাখা যায়। প্রচলিত 5 V TTL লজিকে যেমন: পাঠানো gate “1” বোঝাতে কমপক্ষে ২.৪ V দেয়, আর গ্রহণকারী gate ২.০ V-এর ওপরে পেলেই 1 ধরে নেয়। মাঝের ০.৪ V-এর এই ছাড়টিকে বলে noise margin — এর চেয়ে কম কাঁপুনিতে উত্তর বদলায় না। “0”-এর দিকেও একই রকম: পাঠানো ০.৪ V-এর নিচে, গ্রহণ ০.৮ V পর্যন্ত।

আরও একটি সুবিধা: দুই অবস্থার জগতে লজিক আর হিসাব একই ভাষায় চলে — সত্য/মিথ্যা আর 1/0 একই জিনিস। CMOS transistor কীভাবে এই দুই স্তর তৈরি করে, আর noise margin ও delay কোথা থেকে আসে, তা দেখবেন পর্ব ০৮-এ (Logic gate আর transistor).

Binary লম্বা, তাই octal আর hex

Binary-র একটি অসুবিধা আছে — খুব লম্বা। দশমিক ২৯২৫ লিখতে লাগে ১২টি বিট: 1011 0110 1101. মানুষের চোখে এমন সারি পড়া, মুখে বলা বা খাতায় কপি করা খুব ভুলপ্রবণ। সমাধান হলো এমন একটি ভিত্তি নেওয়া যার মান ২-এর একটি ঘাত। ৮ = ২^৩, তাই একটি octal অঙ্ক ঠিক ৩টি বিট। ১৬ = ২^৪, তাই একটি hex অঙ্ক ঠিক ৪টি বিট — যাকে বলে একটি nibble, আর দুটি hex অঙ্কে একটি পুরো byte (৮ বিট)।

এই ১৬টি সারি মুখস্থ থাকলে binary ↔ hex রূপান্তর হয় চোখের পলকে। কেন দল বানানো কাজ করে, তার প্রমাণ অংশ ৬-এ দেখব। এখন শুধু মনে রাখুন: octal আর hex নতুন কোনো সংখ্যা নয় — একই bit-গুলোকে মানুষের পড়ার মতো করে লেখা। CPU ভেতরে সবসময় binary-ই রাখে।

৩ · ভিত্তি r থেকে দশমিক — Horner-এর পদ্ধতি

সবচেয়ে সরল রাস্তা হলো সূত্রে সরাসরি বসানো। (2A7)₁₆ = ২·১৬^২ + ১০·১৬ + ৭ = ৫১২ + ১৬০ + ৭ = ৬৭৯। কাজ চলে, কিন্তু প্রতিটি ঘরের জন্য আলাদা করে ঘাত হিসাব করতে হয় — অঙ্ক বেশি হলে গুণ অনেক বেশি।

চতুর একটি বিকল্প হলো Horner-এর পদ্ধতি। বহুপদীটিকে ভেতর থেকে বাইরে সাজানো যায়:

অর্থাৎ বাঁ দিক থেকে একটি একটি অঙ্ক পড়ুন, আর প্রতিবার v ← v·r + d. কোনো ঘাত আলাদা করে হিসাব করতে হয় না; n অঙ্কের জন্য মাত্র n−1টি গুণ। এটি বহুপদীর মান বের করার সবচেয়ে কম গুণের সাধারণ পদ্ধতি হিসেবে পরিচিত।

শেষ উদাহরণটি খেয়াল করুন: সংখ্যাগুলো 1, 2, 4, 9, 19, 39, 78, 156 — এগুলো ঠিক সেই ভাগফলগুলো, যা পরের অংশে ১৫৬-কে বারবার ২ দিয়ে ভাগ করলে পাবেন, শুধু উল্টো ক্রমে। Horner আর বারবার ভাগ একই সিঁড়ির ওঠা আর নামা।

ভগ্নাংশ অংশ: বিন্দুর ডানের অঙ্কগুলোর জন্যও Horner চলে, শুধু ডান দিক থেকে আর ভাগ দিয়ে: (0.d₋₁d₋₂d₋₃)_r = (d₋₁ + (d₋₂ + d₋₃/r)/r)/r. ছোট উদাহরণে সরাসরি যোগ করাই সহজ: (1011.101)₂ = ৮ + ২ + ১ + ০.৫ + ০.১২৫ = ১১.৬২৫, আর (2A7.C)₁₆ = ৬৭৯ + ১২/১৬ = ৬৭৯.৭৫।

৪ · দশমিক পূর্ণসংখ্যা থেকে ভিত্তি r — বারবার ভাগ আর তার প্রমাণ

উল্টো দিকের নিয়মটি সবার জানা: সংখ্যাটিকে r দিয়ে ভাগ করতে থাকুন যতক্ষণ না ভাগফল ০ হয়, তারপর ভাগশেষগুলো উল্টো ক্রমে (শেষটি আগে) পড়ুন। এই পদ্ধতির নাম repeated division. কিন্তু কেন উল্টো? আর কেন ভাগশেষই অঙ্ক?

প্রমাণ — এক লাইনের মূল যুক্তি

ধরুন N = (d_k … d₁ d₀)_r. সূত্রটি এভাবে লেখা যায়:

ভাগের নিয়ম (division algorithm) বলে, N-কে r দিয়ে ভাগ করলে ভাগফল q আর ভাগশেষ রাখার উপায় একটিই, যেখানে 0 ≤ ভাগশেষ < r. ওপরের সমীকরণ ঠিক সেই রূপে আছে। তাই ভাগশেষ = d₀ (সবচেয়ে ডানের অঙ্ক), আর ভাগফল q = (d_k … d₁)_r — অর্থাৎ শেষ অঙ্কটি ফেলে দেওয়া একই সংখ্যা। এবার q-কে আবার ভাগ করলে পাওয়া যায় d₁, এভাবে চলতে থাকে (গাণিতিক আরোহ বা induction). প্রতিটি ধাপে ভাগফল কমে, তাই একসময় ০ হবেই। আর প্রথম ভাগশেষটি LSB বলে উত্তর পড়তে হয় নিচ থেকে ওপরে।

Binary-র ক্ষেত্রে ব্যাপারটি চোখে দেখা যায়: ২ দিয়ে ভাগ মানে binary লেখার শেষ বিটটি কেটে ফেলা — যেমন দশমিকে ১০ দিয়ে ভাগ করলে শেষ অঙ্ক কেটে যায় (১৫৬ ÷ ১০ = ১৫, ভাগশেষ ৬)। নিচের stepper-এ প্রতিটি ধাপে একটি অপরিবর্তনীয় সম্পর্ক (invariant) মিলিয়ে দেখানো হয়েছে: ১৫৬ = q · ২^k + (এ পর্যন্ত পাওয়া বিটগুলোর মান). এটি প্রতিটি ধাপে সত্য থাকে, আর শেষে q = ০ হলে বাকি থাকে শুধু উত্তরটি।

ভিত্তি বদলালে শুধু ভাজক বদলায়। ১৫৬-কে ৮ দিয়ে ভাগ করলে ভাগশেষ ৪, ৩, ২ — উত্তর (234)₈. ১৬ দিয়ে ভাগ করলে ১২ (= C) আর ৯ — উত্তর (9C)₁₆. আর ৫৬৬-কে ৫ দিয়ে ভাগ করলে ভাগশেষ ১, ৩, ২, ৪ — উত্তর (4231)₅, যা অংশ ৩-এর Horner-এর হিসাবের সাথে মিলে যায়।

৫ · দশমিক ভগ্নাংশ — বারবার গুণ, আর যে ভগ্নাংশ কখনো শেষ হয় না

ভগ্নাংশের জন্য নিয়মটি উল্টো: ভগ্নাংশটিকে r দিয়ে গুণ করুন। গুণফলের পূর্ণ অংশই পরের অঙ্ক; পূর্ণ অংশ ফেলে বাকি ভগ্নাংশ নিয়ে আবার গুণ করুন। ভগ্নাংশ ০ হলে, বা যত ঘর দরকার তত ঘর পেলে থামুন। এবার অঙ্কগুলো পড়তে হয় ওপর থেকে নিচে — প্রথমটিই বিন্দুর ঠিক পরের অঙ্ক। এর নাম repeated multiplication.

প্রমাণ: ধরুন F = (0.d₋₁d₋₂…)_r = d₋₁/r + d₋₂/r² + … তাহলে r · F = d₋₁ + (d₋₂/r + d₋₃/r² + …)। বন্ধনীর ভেতরের অংশটি (0.d₋₂d₋₃…)_r, যা ১-এর চেয়ে ছোট। তাই r·F-এর পূর্ণ অংশ ঠিক d₋₁, আর ভগ্নাংশ অংশটি বাকি অঙ্কগুলোর সংখ্যা। পূর্ণসংখ্যার ভাগ যেমন ডান দিক থেকে অঙ্ক “কেটে” আনে, গুণ তেমনি বিন্দুর ডান দিক থেকে অঙ্ক বাঁয়ে “টেনে” পূর্ণ অংশে নিয়ে আসে।

কোন ভগ্নাংশ শেষ হয়, কোনটি হয় না — একটি পূর্ণ নিয়ম

৬ নম্বর ধাপের চক্রটি কাকতালীয় নয়। একটি ভগ্নাংশকে লঘিষ্ঠ আকারে p/q লিখুন (p আর q-এর মধ্যে কোনো সাধারণ উৎপাদক নেই)। তাহলে:

০.১ = ১/১০, আর ১০ = ২ × ৫। মৌলিক উৎপাদক ৫ ভিত্তি ২-কে ভাগ করে না — তাই binary-তে অসীম। কিন্তু দশমিকে ১০-কে ২ আর ৫ দুটোই ভাগ করে, তাই ১/২, ১/৪, ১/৫, ১/৮ সব দশমিকে সসীম। উল্টো দিকে ১/৩ দশমিকে অসীম (০.৩৩৩…), কিন্তু ভিত্তি ৩-এ মাত্র (0.1)₃. কোনো ভিত্তিই “নিখুঁত” নয় — প্রতিটি ভিত্তি কিছু ভগ্নাংশ সসীমভাবে লিখতে পারে, কিছু পারে না।

হাতের প্রতিটি পদ্ধতি এবার যন্ত্রে মিলিয়ে নিন। নিচের converter পূর্ণসংখ্যার প্রতিটি ভাগ আর ভগ্নাংশের প্রতিটি গুণ ছাপে, তারপর Horner দিয়ে উল্টো যাচাই করে। একটি সূক্ষ্ম বিষয়: ভগ্নাংশকে এখানে JavaScript-এর সাধারণ দশমিক সংখ্যা হিসেবে না রেখে দুটি পূর্ণসংখ্যার ভাগ (num/den) হিসেবে রাখা হয়েছে — কারণ JavaScript-এর সংখ্যা নিজেই binary floating point, আর তাতে ০.১ আগে থেকেই একটু ভুল। নিজের সংখ্যা দিয়ে বদলে চালিয়ে দেখুন — Run চাপুন:

// Universal base converter: every division / multiplication step is printed.
const DIG = "0123456789ABCDEF";
function intToBase(n, r) {                 // repeated division
  let out = "", steps = [];
  while (n > 0) {
    const q = Math.floor(n / r), d = n % r;
    steps.push(`${n}/${r}=${q} r${DIG[d]}`);
    out = DIG[d] + out; n = q;             // remainders read in reverse
  }
  console.log("   " + steps.join(", "));
  return out || "0";
}
function fracToBase(num, den, r, places, show) {   // exact fraction num/den
  let out = "";
  for (let i = 0; i < places && num !== 0; i++) {
    const p = num * r, d = Math.floor(p / den);
    if (i < show) console.log(`   ${num / den} x ${r} = ${p / den} -> digit ${DIG[d]}`);
    out += DIG[d]; num = p % den;          // keep only the fraction part
  }
  return "0." + out + (num !== 0 ? "..." : "");
}
function fromBase(s, r) {                  // Horner: v = v*r + digit
  let v = 0;
  for (const c of s) v = v * r + DIG.indexOf(c);
  return v;
}
for (const [n, r] of [[156, 2], [156, 8], [156, 16], [566, 5]]) {
  console.log(`${n} (base 10) -> base ${r}`);
  console.log(`   result: ${intToBase(n, r)}`);
}
console.log("0.625 -> base 2");  console.log("   result:", fracToBase(5, 8, 2, 10, 10));
console.log("0.1 -> base 2 (first 5 steps)");  console.log("   20 places:", fracToBase(1, 10, 2, 20, 5));
console.log("0.1 -> base 16:", fracToBase(1, 10, 16, 8, 0));
console.log("Horner check: 10011100_2 =", fromBase("10011100", 2), "| 2A7_16 =", fromBase("2A7", 16), "| 4231_5 =", fromBase("4231", 5));
console.log("4231_5 -> base 7 via decimal:");  console.log("   result:", intToBase(fromBase("4231", 5), 7));

156 (base 10) -> base 2
   156/2=78 r0, 78/2=39 r0, 39/2=19 r1, 19/2=9 r1, 9/2=4 r1, 4/2=2 r0, 2/2=1 r0, 1/2=0 r1
   result: 10011100
156 (base 10) -> base 8
   156/8=19 r4, 19/8=2 r3, 2/8=0 r2
   result: 234
156 (base 10) -> base 16
   156/16=9 rC, 9/16=0 r9
   result: 9C
566 (base 10) -> base 5
   566/5=113 r1, 113/5=22 r3, 22/5=4 r2, 4/5=0 r4
   result: 4231
0.625 -> base 2
   0.625 x 2 = 1.25 -> digit 1
   0.25 x 2 = 0.5 -> digit 0
   0.5 x 2 = 1 -> digit 1
   result: 0.101
0.1 -> base 2 (first 5 steps)
   0.1 x 2 = 0.2 -> digit 0
   0.2 x 2 = 0.4 -> digit 0
   0.4 x 2 = 0.8 -> digit 0
   0.8 x 2 = 1.6 -> digit 1
   0.6 x 2 = 1.2 -> digit 1
   20 places: 0.00011001100110011001...
0.1 -> base 16: 0.19999999...
Horner check: 10011100_2 = 156 | 2A7_16 = 679 | 4231_5 = 566
4231_5 -> base 7 via decimal:
   566/7=80 r6, 80/7=11 r3, 11/7=1 r4, 1/7=0 r1
   result: 1436

৬ · Binary ↔ octal ↔ hex — দল বানানো, আর যেকোনো ভিত্তি থেকে যেকোনো ভিত্তি

Binary থেকে hex করতে ভাগ বা গুণ লাগে না — শুধু বিটগুলোকে বিন্দু থেকে শুরু করে ৪টি করে দলে ভাগ করুন, আর প্রতিটি দলকে একটি hex অঙ্কে বদলান। Octal-এর জন্য দল ৩টি করে। কেন কাজ করে?

প্রমাণ: binary সংখ্যার বিটগুলোকে ডান থেকে ৪টি করে দলে নিন: N = Σ b_i·২ⁱ = Σ_j (b_4j+3·৮ + b_4j+2·৪ + b_4j+1·২ + b_4j) · ২^4j. বন্ধনীর ভেতরের মান h_j সবসময় ০ থেকে ১৫-এর মধ্যে, আর ২^4j = ১৬^j. তাই N = Σ h_j·১৬^j — ঠিক একটি hex সংখ্যার সূত্র, যার অঙ্কগুলো h_j. ভগ্নাংশ অংশে একই যুক্তি ২^−4j = ১৬^−j দিয়ে চলে। Octal-এর জন্য ৪-এর জায়গায় ৩। প্রতিটি দল নিজে নিজে রূপান্তর হয়, এক দল থেকে অন্য দলে কোনো carry যায় না — এটাই এর গতির রহস্য।

bits:  1 0 1 1 0 1 1 0 1 1 0 1
       ↑ MSB               LSB ↑

       1011 │ 0110 │ 1101
weight  8421 │ 8421 │ 8421

       1011 │ 0110 │ 1101
       8+2+1│  4+2 │8+4+1
        =11 │   =6 │  =13
         B  │   6  │   D     ->  0xB6D

       101 │ 101 │ 101 │ 101
weight  421 │ 421 │ 421 │ 421

       101 │ 101 │ 101 │ 101
       4+1 │ 4+1 │ 4+1 │ 4+1
        5  │  5  │  5  │  5     ->  (5555)8

0xB6D   = 11·256 + 6·16 + 13   = 2816 + 96 + 13  = 2925
(5555)8 = 5·512 + 5·64 + 5·8 + 5 = 2560 + 320 + 40 + 5 = 2925

ভগ্নাংশ আর padding — যেখানে সবাই ভুল করেন

বিন্দু থাকলে দল বানাতে হয় বিন্দু থেকে দুই দিকে: পূর্ণ অংশে বিন্দু থেকে বাঁয়ে, ভগ্নাংশে বিন্দু থেকে ডানে। অসম্পূর্ণ দলে 0 বসাতে হয় — পূর্ণ অংশে বাঁ প্রান্তে, ভগ্নাংশে ডান প্রান্তে। উদাহরণ (10110.1011)₂:

• Hex: পূর্ণ অংশ 1 0110 → 0001 0110 = 16; ভগ্নাংশ 1011 = B. উত্তর (16.B)₁₆.
• Octal: পূর্ণ অংশ 10 110 → 010 110 = 26; ভগ্নাংশ 101 1 → 101 100 = 54. উত্তর (26.54)₈.
• যাচাই: তিনটিই ২২.৬৮৭৫ — ২২ + ১১/১৬ = ২২ + ৫/৮ + ৪/৬৪।

ভগ্নাংশের শেষ দলে 0 বাঁয়ে বসালে (001 = 1) উত্তর হতো ২৬.৫১ — সম্পূর্ণ ভুল। কারণ ভগ্নাংশের ডানে 0 বসালে মান বদলায় না (০.১০ = ০.১), কিন্তু বাঁয়ে বসালে বদলায়।

যেকোনো ভিত্তি a থেকে যেকোনো ভিত্তি b

দুটি পথ আছে। সাধারণ পথ — দশমিকের সেতু: প্রথমে Horner দিয়ে a → দশমিক, তারপর বারবার ভাগ দিয়ে দশমিক → b. যেমন (4231)₅ = ৫৬৬, আর ৫৬৬-কে ৭ দিয়ে ভাগ করলে ভাগশেষ ৬, ৩, ৪, ১ — উত্তর (1436)₇. (চাইলে সরাসরি ভিত্তি b-এর হিসাবেই Horner চালানো যায়, কিন্তু অপরিচিত ভিত্তিতে গুণ-যোগ মানুষের জন্য ভুলপ্রবণ।) শর্টকাট — দুটিই ২-এর ঘাত হলে binary-র সেতু: octal → hex করতে আগে প্রতিটি octal অঙ্ককে ৩ বিটে খুলুন, তারপর ৪ বিটে নতুন করে দল বানান। (725)₈ → 111 010 101 → 0001 1101 0101 → (1D5)₁₆; দুটিই দশমিক ৪৬৯। একই কৌশল ভিত্তি ৪ ↔ ১৬ বা ২ ↔ ৩২-এর জন্যও চলে, কারণ শর্ত শুধু একটাই: দুটি ভিত্তিই একই সংখ্যার ঘাত।

এবার একই কাজ C-তে দেখুন। printf নিজেই octal (%o) আর hex (%x, %X) ছাপতে পারে, কিন্তু binary-র জন্য standard কোনো format নেই (C23-এ %b যুক্ত হয়েছে, তবে সব library-তে এখনো নেই) — তাই একটি ছোট হাতে-লেখা ফাংশন। সাথে strtol, যা ভেতরে ঠিক Horner চালিয়ে ২ থেকে ৩৬ পর্যন্ত যেকোনো ভিত্তির লেখা পড়ে:

#include <stdio.h>
#include <stdlib.h>

static void print_bin(unsigned v, int width) {     /* MSB first, space every 4 */
    for (int i = width - 1; i >= 0; i--) {
        putchar(((v >> i) & 1u) ? '1' : '0');
        if (i % 4 == 0 && i != 0) putchar(' ');
    }
    putchar('\n');
}

int main(void) {
    unsigned nums[] = {156, 255, 2925};
    for (int i = 0; i < 3; i++) {
        printf("%4u  %%o=%-5o %%#x=%-#6x %%X=%-4X bin=", nums[i], nums[i], nums[i], nums[i]);
        print_bin(nums[i], 12);
    }
    printf("0xB6D=%d  0b10011100=%d  010=%d (leading 0 = octal!)\n", 0xB6D, 0b10011100, 010);
    printf("__STDC_VERSION__ = %ld\n", (long)__STDC_VERSION__);

    const char *txt[] = {"10011100", "234", "9C", "0x1F", "017"};
    int base[] = {2, 8, 16, 0, 0};                  /* base 0: detect 0x / 0 prefix */
    for (int i = 0; i < 5; i++)
        printf("strtol(\"%s\", base %d) = %ld\n", txt[i], base[i], strtol(txt[i], NULL, base[i]));
    return 0;
}

 156  %o=234   %#x=0x9c   %X=9C   bin=0000 1001 1100
 255  %o=377   %#x=0xff   %X=FF   bin=0000 1111 1111
2925  %o=5555  %#x=0xb6d  %X=B6D  bin=1011 0110 1101
0xB6D=2925  0b10011100=156  010=8 (leading 0 = octal!)
__STDC_VERSION__ = 202311
strtol("10011100", base 2) = 156
strtol("234", base 8) = 156
strtol("9C", base 16) = 156
strtol("0x1F", base 0) = 31
strtol("017", base 0) = 15

Terminal-এ থাকলে bash নিজেও রূপান্তর জানে: $((ভিত্তি#সংখ্যা)) লিখলে যেকোনো ভিত্তি (২ থেকে ৬৪) থেকে দশমিক, আর printf দিয়ে দশমিক থেকে octal বা hex:

printf '%x\n' 255          # decimal -> hex
printf '%o\n' 493          # decimal -> octal
echo $((2#1011))           # binary  -> decimal
echo $((16#ff))            # hex     -> decimal
echo $((8#755)) $((5#4231))   # octal and base 5 -> decimal
printf '%d\n' 0x1F         # printf also reads 0x... as hex
if command -v bc >/dev/null; then echo "obase=2; 156" | bc; else echo "bc নেই"; fi

ff
755
11
255
493 566
31
bc নেই

৭ · কত বিট লাগে, ২-এর ঘাত, KB বনাম KiB — আর hex-এর বাস্তব জগৎ

n বিটে ২ⁿটি মান

প্রতিটি বিট দুই রকম হতে পারে, আর বিটগুলো স্বাধীন — তাই n বিটে মোট ২ × ২ × … × ২ = ২ⁿ রকম নকশা। Unsigned পূর্ণসংখ্যা হিসেবে এগুলো ০ থেকে ২ⁿ − ১। উল্টো প্রশ্নটি পরীক্ষায় বেশি আসে: ০ থেকে N পর্যন্ত সব মান রাখতে কত বিট লাগবে? আমাদের দরকার N + ১টি আলাদা নকশা, তাই সবচেয়ে ছোট n যেন ২ⁿ ≥ N + ১:

• N = ২৫৫: ২^৮ = ২৫৬ ≥ ২৫৬, তাই ৮ বিট। N = ২৫৬: লাগে ২৫৭টি নকশা, ২^৮ যথেষ্ট নয় — ৯ বিট। একটি সংখ্যা বাড়লেই একটি বিট বেশি!
• N = ১০০০: ২^৯ = ৫১২ < ১০০১ ≤ ১০২৪ = ২^১০, তাই ১০ বিট।
• ১১ অঙ্কের মোবাইল নম্বর (সর্বোচ্চ ৯৯,৯৯৯,৯৯৯,৯৯৯) পূর্ণসংখ্যা হিসেবে রাখতে: log₂(১০^১১) ≈ ৩৬.৫৪, তাই ৩৭ বিট — ৩২-বিটের int-এ আঁটবে না। সাধারণ নিয়ম: d অঙ্কের দশমিক সংখ্যায় লাগে প্রায় d × ৩.৩২ বিট, কারণ log₂১০ ≈ ৩.৩২।
• ধরুন ১৭ কোটি মানুষকে আলাদা পরিচয়-নম্বর দিতে হবে: ২^২৭ ≈ ১৩.৪ কোটি যথেষ্ট নয়, ২^২৮ ≈ ২৬.৮ কোটি যথেষ্ট — ২৮ বিট।

SI বনাম IEC — ৫০০ GB ডিস্ক কেন “৪৬৫ GB” দেখায়

নতুন ল্যাপটপ কিনে অনেকেই অবাক হন: বাক্সে লেখা ৫০০ GB, কিন্তু Windows দেখাচ্ছে প্রায় ৪৬৫ GB. কেউ কিছু চুরি করেনি — দুই পক্ষ দুটি আলাদা “কিলো” ব্যবহার করছে। SI prefix-এ kilo = ১০^৩, mega = ১০^৬, giga = ১০^৯ — ডিস্ক নির্মাতারা এটাই মানেন। কিন্তু মেমরি address স্বাভাবিকভাবেই ২-এর ঘাতে বাড়ে, তাই কম্পিউটার জগতে বহুদিন “KB” বলতে ১০২৪ বোঝানো হতো। এই দ্ব্যর্থতা দূর করতে IEC ১৯৯৮ সালে আলাদা নাম দেয় — IEC binary prefix: kibi (KiB = ২^১০), mebi (MiB = ২^২০), gibi (GiB = ২^৩০), tebi (TiB = ২^৪০)।

Hex চারপাশেই

একবার চিনলে hex সবখানে চোখে পড়বে — কারণ যেখানেই byte-এর হিসাব, সেখানেই প্রতি byte-এ দুটি hex অঙ্ক সবচেয়ে পরিষ্কার লেখা।

৮ · Binary আর hex-এ সরাসরি হিসাব — যোগ, বিয়োগ, shift দিয়ে গুণ

দশমিকে ফিরে না গিয়েও যেকোনো ভিত্তিতে হিসাব করা যায় — নিয়ম একই, শুধু “১০ হলে হাতে এক” বদলে হয় “r হলে হাতে এক”। এখানে আমরা শুধু ধনাত্মক (unsigned) সংখ্যা নিচ্ছি; ঋণাত্মক সংখ্যা কীভাবে রাখা হয় আর বিয়োগকে কীভাবে যোগে বদলানো হয়, সেটি পর্ব ০৫-এর বিষয়।

Binary যোগ — carry

নিয়ম মাত্র চারটি: ০ + ০ = ০, ০ + ১ = ১, ১ + ১ = ১০ (লিখুন 0, হাতে 1), আর ১ + ১ + ১ = ১১ (লিখুন 1, হাতে 1). হাতে রাখা অঙ্কটির নাম carry.

  carry   1 1 1 1
            1 0 1 1      (11)
          + 0 1 1 1      ( 7)
          ---------
          1 0 0 1 0      (18)

ডান থেকে: ১ + ১ = ১০ → 0, carry 1; ১ + ১ + ১ = ১১ → 1, carry 1; ০ + ১ + ১ = ১০ → 0, carry 1; ১ + ০ + ১ = ১০ → 0, carry 1; শেষ carry নিজেই একটি নতুন বিট। খেয়াল করুন, দুটি ৪ বিটের সংখ্যা যোগ করে পেলাম ৫ বিট। যদি যন্ত্রের register মাত্র ৪ বিটের হয়, শেষ carry-টি জায়গা পায় না — ফল দেখাবে 0010 = ২। এটিই unsigned overflow, যা x86 বা ARM-এর মতো CPU একটি flag-এ জানিয়ে দেয়; RISC-V-এ flag নেই (পর্ব ০৫ ও পর্ব ২০)। প্রতিটি ঘরের এই “তিনটি বিট ঢোকে, যোগফল আর carry বের হয়” কাজটিই full adder circuit, যা পর্ব ১১-এ বানাবেন।

Binary বিয়োগ — borrow

বড় থেকে ছোট বিয়োগ (unsigned): ০ − ১ করতে হলে বাঁয়ের ঘর থেকে একটি borrow নিতে হয়, যা এই ঘরে ২-এর সমান। দশমিকে যেমন ধার করা ১ পাশের ঘরে ১০ হয়ে আসে।

            1 1 0 0      (12)
          − 0 1 0 1      ( 5)
          ---------
            0 1 1 1      ( 7)

ডান থেকে ঘর ০, ১, ২, ৩ ধরে: ঘর ০-এ ০ − ১ পারা যায় না, আর ঠিক বাঁয়ের ঘর ১-ও 0 — তাই ধার আসে ঘর ২-এর 1 থেকে। ঘর ২ হয় 0, ঘর ১ পায় ২, তা থেকে ১ পাঠায় ঘর ০-তে; ফলে ঘর ১-এ থাকে 1 আর ঘর ০ পায় ২। এখন ঘর ০: ২ − ১ = ১; ঘর ১: ১ − ০ = ১; ঘর ২: ০ − ১ — আবার ধার লাগে, এবার ঘর ৩-এর 1 থেকে: ২ − ১ = ১, আর ঘর ৩ হয় 0; ঘর ৩: ০ − ০ = ০। উত্তর 0111 = ৭। ছোট থেকে বড় বিয়োগ করতে গেলে সবচেয়ে বাঁয়ের ঘরেও ধার লাগে, কিন্তু ধার দেওয়ার মতো কোনো ঘর থাকে না — সেটাই ঋণাত্মক ফলের সংকেত, যা unsigned-এ রাখা যায় না।

Shift দিয়ে গুণ

দশমিকে ১০ দিয়ে গুণ মানে ডানে একটি ০ বসানো। একইভাবে binary-তে ২ দিয়ে গুণ মানে সব বিট এক ঘর বাঁয়ে সরানো (left shift): 1101 (১৩) → 11010 (২৬)। ২^k দিয়ে গুণ মানে k ঘর shift — আর hex-এ ১৬ দিয়ে গুণ মানে একটি hex অঙ্ক সরানো, অর্থাৎ ৪ বিট: 0x2B × ১৬ = 0x2B0. অন্য সংখ্যা দিয়ে গুণ করতে তাকে ২-এর ঘাতে ভাঙুন: ১৩ × ১০ = ১৩ × (৮ + ২) = (১৩ ≪ ৩) + (১৩ ≪ ১) = ১০৪ + ২৬ = ১৩০। Compiler প্রায়ই ঠিক এভাবে ধ্রুবক দিয়ে গুণকে shift আর যোগে বদলে দেয়।

সাধারণ binary গুণও খাতার লম্বা গুণের মতো, শুধু প্রতিটি সারি হয় পুরো সংখ্যা (অঙ্ক 1) নয়তো ০ (অঙ্ক 0): 1011 × 101 = 1011 + 101100 = 110111, অর্থাৎ ১১ × ৫ = ৫৫। এই “shift আর যোগ” থেকেই hardware multiplier শুরু হয়, যা পর্ব ২১-এ Booth-এর পদ্ধতিসহ দেখবেন।

Hex যোগ — ১৬ হলে হাতে এক

  carry     1 1 1
            3 A 7 F      (14975)
          + 1 C 9 6      ( 7318)
          ---------
            5 7 1 5      (22293)

ডান থেকে: F + 6 = ১৫ + ৬ = ২১ = ১৬ + ৫ → লিখুন 5, carry 1. 7 + 9 + 1 = ১৭ = ১৬ + ১ → 1, carry 1. A + C + 1 = ১০ + ১২ + ১ = ২৩ = ১৬ + ৭ → 7, carry 1. 3 + 1 + 1 = ৫। উত্তর 0x5715, দশমিকে ১৪৯৭৫ + ৭৩১৮ = ২২২৯৩ — মিলে গেছে। কৌশল একটাই: প্রতিটি ঘরে দশমিকে যোগ করে ১৬ বা তার বেশি হলে ১৬ বাদ দিয়ে carry 1.

৯ · সংখ্যার কোড — BCD, excess-3 আর Gray code

এতক্ষণ বিট-নকশা মানেই ছিল একটি binary সংখ্যা। কিন্তু একই বিটগুলোকে অন্য নিয়মে অর্থ দেওয়া যায় — একে বলে কোড। তিনটি কোড digital logic-এর পরীক্ষায় আর বাস্তব hardware-এ বারবার আসে।

BCD (8421) — প্রতিটি দশমিক অঙ্ক আলাদা ৪ বিটে

BCD (Binary Coded Decimal)-এ পুরো সংখ্যাকে binary করা হয় না; প্রতিটি দশমিক অঙ্ককে আলাদাভাবে ৪ বিটে লেখা হয়, ওজন 8-4-2-1. ৮৫ → 1000 0101 (৮ আর ৫), যেখানে সাধারণ binary-তে ৮৫ = 101 0101. ৪ বিটে ১৬টি নকশা, কিন্তু ব্যবহার হয় মাত্র ১০টি — 1010 থেকে 1111 BCD-তে অবৈধ। জায়গা কিছুটা নষ্ট হয়, বিনিময়ে দশমিক দেখানো খুব সহজ: ক্যালকুলেটর, ডিজিটাল ঘড়ি, পেট্রোল পাম্পের মিটার বা বাসের ভাড়ার ডিসপ্লের ৭-segment অঙ্কে প্রতিটি nibble সরাসরি একটি অঙ্ক — ভাগ করে অঙ্ক বের করতে হয় না। BCD থেকে ৭-segment চালানোর decoder circuit পর্ব ১২-এ আসবে।

BCD যোগ আর +6 সংশোধন: দুটি BCD অঙ্ক সাধারণ binary নিয়মে যোগ করুন। যোগফল ৯-এর বেশি হলে (অর্থাৎ ফল একটি অবৈধ নকশা, অথবা nibble থেকে carry বেরিয়েছে) তার সাথে 0110 (৬) যোগ করুন। কেন ৬? কারণ ৪ বিটের nibble ১৬-তে উপচে পড়ে, আর দশমিক অঙ্ক উপচে পড়া উচিত ১০-এ — মাঝের ১৬ − ১০ = ৬টি অব্যবহৃত নকশা লাফিয়ে পার হতে ৬ যোগ করতে হয়। তখন যে carry বের হয়, সেটিই পরের দশমিক অঙ্কে যায়।

Excess-3 — নিজেই নিজের পরিপূরক

Excess-3 কোডে প্রতিটি দশমিক অঙ্কের সাথে ৩ যোগ করে ৪ বিটে লেখা হয়: ০ → 0011, ৪ → 0111, ৯ → 1100. এর একটি সুন্দর গুণ: অঙ্ক d-এর ৯-এর পরিপূরক (৯ − d)-এর কোড পাওয়া যায় শুধু সব বিট উল্টে দিয়ে। ৪-এর কোড 0111, উল্টালে 1000 = ৫ + ৩ — অর্থাৎ ৯ − ৪ = ৫-এর কোড। কারণ d + ৩ আর (৯ − d) + ৩-এর যোগফল সবসময় ১৫ = 1111. এমন কোডকে বলে self-complementing code; পুরোনো দশমিক যন্ত্রে বিয়োগ করার জন্য এটি কাজে লাগত।

Gray code — প্রতি ধাপে ঠিক একটি বিট

সাধারণ binary-তে ৭ → ৮ যেতে চারটি বিটই বদলায় (0111 → 1000). বাস্তব circuit-এ চারটি বিট কখনো ঠিক একই মুহূর্তে বদলায় না; মাঝের এক ঝলকে যন্ত্র ভুল করে 1111 বা 0000 পড়তে পারে। Gray code-এ পরপর দুটি মানের মধ্যে ঠিক একটি বিট বদলায় — অর্থাৎ পাশাপাশি দুটি কোডের Hamming distance ১। তাই পড়ার মুহূর্তে বড়জোর পুরোনো বা নতুন মানটি আসে, কোনো তৃতীয় আজব মান নয়।

কেন এক বিট বদলায় — ছোট প্রমাণ: b থেকে b + ১ হলে ডানের যে কয়টি 1 আছে সেগুলো 0 হয় আর ঠিক তার বাঁয়ের 0-টি 1 হয় — ধরুন অবস্থান k থেকে নিচ পর্যন্ত সব বিট উল্টায়। g_i = b_i ⊕ b_i+1; i < k হলে b_i আর b_i+1 দুটোই উল্টায়, তাই তাদের XOR বদলায় না। i = k হলে b_k উল্টায় কিন্তু b_k+1 উল্টায় না, তাই g_k বদলায়। i > k হলে কিছুই বদলায় না। ফলে ঠিক একটি Gray বিট — g_k — বদলায়।

কোথায় লাগে? কোণ মাপার rotary encoder-এর চাকতিতে, K-map-এর সারি-কলামের ক্রমে (00, 01, 11, 10 — পর্ব ০৯), আর ভিন্ন clock-এ চলা দুটি circuit-এর মধ্যে counter-এর মান পাঠাতে (পর্ব ১৮)। বিস্তারিত ইতিহাস আর ব্যবহার নিচের ভাবনার প্রশ্ন ৫-এ।

নিচের টুলটি BCD যোগ ঘর ধরে ধরে +6 সংশোধনসহ দেখায়, তারপর ০–১৫-এর Gray টেবিল বানায় — প্রতিটি সারিতে আগের Gray কোড থেকে কয়টি বিট বদলাল (১৫ থেকে ০-তে ফিরে আসাও ধরে) আর Gray থেকে ফিরিয়ে আনা মান:

// BCD (8421) addition with the +6 correction, and the 4-bit Gray code table.
const nib = (x) => x.toString(2).padStart(4, "0");
const toBCD = (n) => String(n).split("").map((c) => nib(+c)).join(" ");
function bcdAdd(a, b) {
  const len = Math.max(String(a).length, String(b).length);
  const A = String(a).padStart(len, "0"), B = String(b).padStart(len, "0");
  let carry = 0, out = [];
  for (let i = len - 1; i >= 0; i--) {     // rightmost digit first
    let s = +A[i] + +B[i] + carry;
    let line = `  ${nib(+A[i])} + ${nib(+B[i])} + ${carry} = ${s.toString(2).padStart(5, "0")} (${s})`;
    if (s > 9) { s += 6; line += ` > 9, +0110 -> ${s.toString(2).padStart(5, "0")}`; }
    carry = s >> 4; out.unshift(nib(s & 15));
    console.log(line + `  keep ${nib(s & 15)}, carry ${carry}`);
  }
  if (carry) out.unshift("0001");
  return out.join(" ");
}
for (const [a, b] of [[47, 38], [9, 9]]) {
  console.log(`${a} = ${toBCD(a)}, ${b} = ${toBCD(b)}`);
  console.log(`${a} + ${b} in BCD = ${bcdAdd(a, b)}  (BCD of ${a + b}: ${toBCD(a + b)})`);
}
console.log(`plain binary 85 = ${(85).toString(2)} -- a different pattern`);
const gray = (b) => b ^ (b >> 1);
function grayToBin(g) { let b = 0; for (; g; g >>= 1) b ^= g; return b; }
console.log("\n n  binary  gray  bits changed  back");
let prev = gray(15);                        // wrap-around: 15 -> 0
for (let n = 0; n < 16; n++) {
  const g = gray(n), diff = (g ^ prev).toString(2).split("1").length - 1;
  console.log(`${String(n).padStart(2)}   ${nib(n)}   ${nib(g)}      ${diff}        ${grayToBin(g)}`);
  prev = g;
}

47 = 0100 0111, 38 = 0011 1000
  0111 + 1000 + 0 = 01111 (15) > 9, +0110 -> 10101  keep 0101, carry 1
  0100 + 0011 + 1 = 01000 (8)  keep 1000, carry 0
47 + 38 in BCD = 1000 0101  (BCD of 85: 1000 0101)
9 = 1001, 9 = 1001
  1001 + 1001 + 0 = 10010 (18) > 9, +0110 -> 11000  keep 1000, carry 1
9 + 9 in BCD = 0001 1000  (BCD of 18: 0001 1000)
plain binary 85 = 1010101 -- a different pattern

 n  binary  gray  bits changed  back
 0   0000   0000      1        0
 1   0001   0001      1        1
 2   0010   0011      1        2
 3   0011   0010      1        3
 4   0100   0110      1        4
 ...
 7   0111   0100      1        7
 8   1000   1100      1        8
 ...
14   1110   1001      1        14
15   1111   1000      1        15

১০ · AI-এর যুগে — রূপান্তর নিজে যাচাই করুন

সংখ্যা রূপান্তরের প্রশ্নে AI-এর উত্তর বেশিরভাগ সময় ঠিক থাকে — কিন্তু সবসময় নয়। ভাষা মডেল হিসাব করে না, পরের শব্দ অনুমান করে — তাই লম্বা binary সারিতে একটি বিট বাদ পড়া, ভগ্নাংশের দলে ভুল দিকে 0 বসানো, বা GB আর GiB গুলিয়ে ফেলা খুব স্বাভাবিক ভুল।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• উত্তরটিকে উল্টো দিকে (Horner দিয়ে) দশমিকে ফিরিয়ে মিলিয়েছি
• বিটের সংখ্যা গুনেছি, আর ⌈log₂(N+1)⌉-এর সাথে মিলিয়েছি
• ভগ্নাংশ থাকলে padding-এর দিক আর সসীম কি না যাচাই করেছি
• একটি স্বাধীন যন্ত্রে মিলিয়েছি — এই পর্বের converter, bash-এর $((2#…)), বা Python-এর int("…", 2)
• একক (GB/GiB, bit/byte) আর কোড (binary নাকি BCD নাকি Gray) পরিষ্কার লেখা আছে