Problem link ও উৎস
- Original source: Classic beginner exercise
- Platform: Classic exercise
- Topic: Math-based programming fundamentals → Level 0: Absolute Basics
- Difficulty: Easy
- Pattern: mod 10
- Basic idea inherited from: 001 (Even or Odd)
## প্রশ্ন ও উদাহরণ {#problem}
### সহজ করে প্রশ্ন {#1-problem-in-simple-words}
একটা integer `n` দেওয়া আছে। তার **last digit** (সবচেয়ে ডানদিকের সংখ্যাটা) বের করতে হবে। ব্যস, এটুকুই।
যেমন `1234`-এর last digit `4`, `7`-এর last digit `7`, `90`-এর last digit `0`।
দেখতে তুচ্ছ, কিন্তু এটাই digit নিয়ে কাজের একদম ভিত্তি — last digit তুলতে পারা মানে digit extraction-এর প্রথম ইট গাঁথা।
### Input ও output {#6-example-input-and-output}
```text
input -> output (কীভাবে)
------------------------------
1234 -> 4 (1234 % 10)
7 -> 7 (একটাই digit, সে-ই last)
0 -> 0 (0 % 10 = 0)
90 -> 0 (শেষে শূন্য, last digit 0)
100 -> 0
-1234 -> 4 (চিহ্ন বাদ দিয়ে digit-ই চাই)
```
দুটো জিনিস খেয়াল করো: **শেষে শূন্য থাকলে last digit 0** (যেমন 90, 100), আর **negative সংখ্যায়** আমরা সাধারণত চিহ্ন বাদ দিয়ে digit-টাই চাই (নিচে section 17-এ Python-এর `%`-এর খটকা আছে — তাই `abs()` নিরাপদ)।
### চেনা উদাহরণে বোঝা {#4-real-life-analogy}
ভাবো একটা লম্বা **train**, পেছন থেকে দেখছ। তোমার শুধু **শেষ বগি**-টা দরকার — সামনের ইঞ্জিন বা মাঝের বগি ক'টা, সে নিয়ে মাথা ঘামানোর দরকার নেই।
- পুরো train = পুরো সংখ্যা `1234`
- শেষ বগি = last digit `4`
- "শেষ বগিটা কোনটা?" — এই প্রশ্নের উত্তর এক ঝলকেই দেওয়া যায়, পুরো train মাপতে হয় না
`n % 10` আসলে তোমাকে সরাসরি সেই শেষ বগিটাই এনে দেয় — train কত লম্বা তা না গুনেই।
## ভিত্তির ধারণা {#idea}
### আগের কোন ধারণাটি লাগবে {#3-which-basic-idea-does-this-inherit-from}
সরাসরি **001 (Even or Odd)** থেকে।
001-এ আমরা শিখেছিলাম — পুরো সংখ্যা না দেখে শুধু **শেষটা** দেখলেই চলে, আর সেই শেষটা ধরিয়ে দেয় `%` operator। শুধু 001-এ আমরা 2 দিয়ে ভাগ করে last *bit* দেখতাম; এখানে 10 দিয়ে ভাগ করে last *digit* দেখছি:
```
001: n % 2 -> last bit (even/odd)
008: n % 10 -> last digit (একই "শেষ ছোঁয়ার" চিন্তা, base বদলে গেছে মাত্র)
```
আর 002-এর সাথেও আত্মীয়তা গভীর: 002-এ এই `% 10` একটা loop-এর ভেতরে বসে সব digit তুলত। 008 হলো সেই loop-এর **প্রথম পদক্ষেপ** — মাত্র একবার `% 10`। মানে 002 জানলে 008 এমনিই পারো; আবার 008 না বুঝলে 002-এর loop-ও আবছা থাকবে।
### ভেতরের অঙ্ক {#2-what-is-the-math-idea}
মূল idea একটাই — **remainder by 10**। কোনো সংখ্যাকে 10 দিয়ে ভাগ করলে যা বাকি থাকে, সেটাই তার last digit।
Python-এ:
```
n % 10 -> last digit
```
কেন? কারণ আমরা base-10 (দশমিক) system-এ লিখি। `1234` মানে আসলে `1×1000 + 2×100 + 3×10 + 4×1`। প্রথম তিনটা term-ই 10 দিয়ে নিঃশেষে ভাগ যায় (1000, 100, 10 সবই 10-এর গুণিতক), তাই 10 দিয়ে ভাগ করলে শুধু শেষের `4` বাকি থাকে। মানে **last digit হলো সেই অংশ যেটা 10-এর ঘরে আঁটে না**।
## ধাপে ধাপে সমাধান {#walkthrough}
### প্রথম সরল উপায় {#7-brute-force-thinking}
`% 10`-এর কথা যদি মাথায় না আসে? তখন "হাতে গুনে" করার পথ — সংখ্যাটাকে **string বানিয়ে** শেষ অক্ষরটা তুলে আনি:
```python
def last_digit_str(n):
s = str(abs(n)) # 1234 -> "1234"
return int(s[-1]) # শেষ অক্ষর '4' -> 4
```
এটা কাজ করে, ঠিক উত্তর দেয়, পড়তেও সহজ। আরেকটা আরও "সৎ" কিন্তু বোকা পথ — 002-এর মতো পুরো peeling loop চালিয়ে last digit-এ পৌঁছানো, যদিও আমাদের শুধু প্রথম ধাপটাই দরকার।
### কোথায় বেশি কাজ হতে পারে {#8-why-brute-force-may-be-slow}
সত্যি বলতে এখানে কোনোটাই খুব "ধীর" নয় — last digit তো এক ধাপের ব্যাপার। কিন্তু string version-এ লুকোনো খরচ আছে:
- **বাড়তি জায়গা:** `str(n)` একটা নতুন string বানায় — O(digit) extra space। `n % 10`-এ সেটা লাগে না (O(1) space)।
- **অপ্রয়োজনীয় কাজ:** শুধু শেষ digit চাই, অথচ string বানাতে গিয়ে **সব** digit মেমরিতে তুলছি — train-এর শেষ বগি দেখতে গোটা train কাগজে আঁকার মতো।
- **ভাষা-নির্ভরতা:** C++/Java-তে int → string যাওয়া-আসা ঝামেলার; `% 10` যেকোনো ভাষায় এক লাইন।
```text
n = 9999999999 হলে:
string পথ : পুরো 10 digit-এর string বানাও, তারপর শেষ অক্ষর (O(digit) space)
smart পথ : ঠিক একটা % 10 (O(1), চোখের নিমেষে)
```
মূল শিক্ষা: যেটা **এক ধাপে** জানা যায়, তার জন্য পুরো সংখ্যা ঘাঁটা অপচয়।
### আরও ভালোভাবে ভাবা {#9-better-thinking}
পুরো train মাপা বাদ — সরাসরি জিজ্ঞেস করি "10 দিয়ে ভাগ করলে কত বাকি?" সেটাই last digit:
```python
def last_digit(n):
return abs(n) % 10
```
একটাই operation, সংখ্যা যত বড়ই হোক। এটাই O(1) — constant time। কোনো string নেই, কোনো loop নেই।
### ভাবনার পরিবর্তন {#10-thinking-tweak}
আসল "আহা!" মুহূর্ত — **last digit = `n % 10`, কারণ base-10-এ 10-এর সব গুণিতক (10, 100, 1000...) `% 10` করলে মিলিয়ে যায়, পড়ে থাকে শুধু একক ঘরের অঙ্ক।**
এই idea-টা generalize হয়:
- শেষ **দুই** digit চাও? → `n % 100`
- শেষ **তিন** digit চাও? → `n % 1000`
- মানে `n % 10^k` দেয় শেষ `k`টা digit।
এই "`% 10^k` দিয়ে শেষ k digit কাটা" tweak-টা মাথায় গেঁথে নাও — power-এর unit digit বা cyclicity-র problem-এ এটাই প্রাণ।
### ছবিতে বোঝা {#5-visual-explanation}
`1234`-কে digit-এর বাক্স ভাবো; last digit মানে একদম ডানের বাক্সটা:
```text
1234 -> [ 1 ][ 2 ][ 3 ][ 4 ]
^^^
শুধু এই ডান বাক্সটাই চাই
n % 10 -> ডান বাক্সের ভেতরের সংখ্যা = 4
```
কেন `% 10` ঠিক ওই বাক্সটাই দেয়, place value দিয়ে দেখো:
```text
1234 = 1×1000 + 2×100 + 3×10 + 4×1
\________________/ \_/
এই অংশ 10 দিয়ে ভাগ যায় এই 4 বাকি থাকে
(1230, পুরোটা 10-এর গুণিতক) -> তাই last digit
```
লক্ষ করো — সংখ্যাটা কত বড় তাতে কিছু আসে যায় না, 10-এর ঘরে আঁটে না এমন শেষ অংশটাই উত্তর।
### ছোট input-এ ধাপে ধাপে {#11-step-by-step-dry-run}
`n = 1234` ধীরে চালাই — smart way তো এক লাইন, তাই আগে সেটা, পরে string পথটা মিলিয়ে দেখি:
smart way:
```text
abs(1234) = 1234
1234 % 10 -> 1234 = 10×123 + 4 -> remainder 4 -> last digit 4
```
এক ধাপেই উত্তর 4।
এবার string পথ পাশে রেখে মিলিয়ে নিই:
| step | কী করছি | ফল |
| --- | --- | --- |
| 1 | `abs(1234)` | `1234` |
| 2 | `str(1234)` | `"1234"` |
| 3 | `s[-1]` (শেষ অক্ষর) | `'4'` |
| 4 | `int('4')` | `4` |
দুই পথেই উত্তর **4** — একই সত্য, কিন্তু `% 10` সোজা গন্তব্যে নিয়ে গেল, string পথ চারটে ধাপ ঘুরে।
## কোড ও ব্যাখ্যা {#code}
### Python {#12-python-solution}
```python
def last_digit(n):
"""n-এর last digit (চিহ্ন বাদ দিয়ে) ফেরত দেয়।"""
return abs(n) % 10
def last_digit_str(n):
"""একই উত্তর, string পদ্ধতি (তুলনার জন্য)।"""
return int(str(abs(n))[-1])
def last_k_digits(n, k):
"""বোনাস: শেষ k-টা digit একসাথে (% 10^k)।"""
return abs(n) % (10 ** k)
# --- ছোট test গুলো (সব pass করা উচিত) ---
assert last_digit(1234) == 4
assert last_digit(7) == 7
assert last_digit(0) == 0 # 0-এর last digit 0
assert last_digit(90) == 0 # শেষে শূন্য
assert last_digit(100) == 0
assert last_digit(-1234) == 4 # চিহ্ন বাদ
assert last_digit_str(1234) == 4 # দুই পদ্ধতি মেলে
assert last_digit_str(0) == 0
assert last_k_digits(1234, 2) == 34 # শেষ দুই digit
assert last_k_digits(5, 3) == 5 # digit কম হলে সংখ্যাটাই
print(last_digit(1234)) # 4
print(last_digit(90)) # 0
print(last_digit(-1234)) # 4
print("সব test pass!")
```
### কোডের প্রতিটি অংশ {#13-line-by-line-explanation}
```
def last_digit(n):
return abs(n) % 10
```
এটাই হৃদয়। `abs(n)` আগে চিহ্ন সরায় (যাতে negative-এ গোলমাল না হয় — নিচে common mistake দেখো), তারপর `% 10` last digit তুলে আনে। পুরো কাজ এক লাইনে, এক ধাপে।
```
def last_digit_str(n):
return int(str(abs(n))[-1])
```
`str(abs(n))` সংখ্যাকে string বানায়, `[-1]` তার শেষ অক্ষর নেয় (Python-এ `-1` মানে "শেষ থেকে এক"), `int()` সেই অক্ষরকে আবার সংখ্যা বানায়। কাজ করে, কিন্তু ভেতরে string তৈরি হয়।
```
def last_k_digits(n, k):
return abs(n) % (10 ** k)
```
বোনাস — `10 ** k` মানে `10`-এর `k` power (যেমন `10 ** 2 = 100`)। `% 100` দেয় শেষ দুই digit, `% 1000` শেষ তিন। section 10-এর generalize করা idea-টাই code-এ।
বাকি `assert` লাইনগুলো নিজেদের চেক করছে — উত্তর না মিললে program সেখানেই থেমে error দেবে। সব ঠিক থাকলে শেষে `সব test pass!` ছাপে।
### Output মিলিয়ে দেখা {#14-output-walkthrough}
চালালে যা ছাপবে:
```text
4
0
4
সব test pass!
```
প্রথম তিন লাইন তিনটা `print(last_digit(...))` থেকে: 1234 → 4, 90 → 0 (শেষে শূন্য ঠিকঠাক ধরা পড়ল), -1234 → 4 (চিহ্ন বাদ)। তার আগের সব `assert` চুপচাপ pass করেছে (assert pass করলে কিছু ছাপে না)। সবশেষে `সব test pass!` — সব ঠিক আছে।
## খরচ ও সাধারণ ভুল {#cost}
### সময় {#15-time-complexity}
**O(1)** — constant time। `n` যত বড়ই হোক, একটাই `%` operation, একটাই তুলনা। সংখ্যার আকারের সাথে কাজ বাড়ে না।
(string version O(digit) — কারণ পুরো সংখ্যাকে string বানাতে সব digit পড়তে হয়; তাই last digit-এর জন্য সেটা একটু অপচয়।)
### অতিরিক্ত জায়গা {#16-space-complexity}
**O(1)** — `% 10` পদ্ধতিতে কোনো বাড়তি list বা string লাগে না, শুধু গুটিকয় variable। (string version-এ O(digit), কারণ পুরো string মেমরিতে বানায়।)
### যে ভুলগুলো এড়াতে হবে {#17-common-mistakes}
1. **negative-এ সরাসরি `n % 10`** — Python-এ `-1234 % 10` দেয় `6` (Python-এর modulo সবসময় 0..9-এর মধ্যে positive থাকে), অথচ আমরা চাই `4`। তাই আগে `abs(n)` নাও। (C++/Java-তে `-1234 % 10` দেয় `-4` — আরেক রকম গোলমাল।) তাই **চিহ্ন আগে সামলাও**।
2. **`% 10` আর `// 10` গুলিয়ে ফেলা** — `% 10` last digit *দেয়*, `// 10` last digit *ফেলে* দেয়। last digit চাইলে `%`, peeling চাইলে `//`।
3. **`% 2` লিখে ফেলা** — 001-এর অভ্যাসে; digit চাই বলে `% 10` লাগবে, `% 2` নয়।
4. **শেষের শূন্য নিয়ে দ্বিধা** — `90`-এর last digit `0`, এটা ঠিক; "শূন্য কি digit?" — হ্যাঁ, অবশ্যই।
5. **এই জন্য string বানানো** — অভ্যাসবশত অনেকে `str(n)[-1]` লেখে; `% 10` সরাসরি, দ্রুত, কম স্মৃতি।
## শেখা ও পরের অনুশীলন {#practice}
### এই ধারণার পরের অনুশীলন {#18-harder-problems-that-inherit-this-idea}
- **LeetCode — Add Digits** (