diff --git a/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md b/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
index c66a1a219..5e7e7c317 100644
--- a/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
+++ b/9-regular-expressions/15-regexp-catastrophic-backtracking/article.md
@@ -1,22 +1,22 @@
-# Catastrophic backtracking
+# ধ্বংসাত্নক ব্যাকট্রাকিং (Catastrophic backtracking)
-Some regular expressions are looking simple, but can execute a veeeeeery long time, and even "hang" the JavaScript engine.
+কিছু রেগুলার এক্সপ্রেশন দেখতে মনে হয় সাধারণ, কিন্তু এদের এক্সিকিউশনে সময় এত বেশি নেয়, এরা জাভাস্ক্রিপ্ট ইঞ্জিনকে "হ্যাং" করে দিতে পারে।
-Sooner or later most developers occasionally face such behavior. The typical symptom -- a regular expression works fine sometimes, but for certain strings it "hangs", consuming 100% of CPU.
+বেশিরভাগ ডেভলাপারই আগে বা পরে এই বিপর্যয়ের সম্মুখীন হন, কেননা এ ধরণের রেগুলার এক্সপ্রেশন লিখা সহজ। সাধারণত -- অনেক সময় এই রেগুলার এক্সপ্রেশনগুলো কাজ করে, কিন্তু কিছু নির্দিষ্ট স্ট্রিংয়ের জন্য এরা ১০০% সিপিউ ব্যবহারের মাধ্যমে "হ্যাং" হয়ে যায়।
-In such case a web-browser suggests to kill the script and reload the page. Not a good thing for sure.
+এক্ষেত্রে ওয়েব ব্রাউজার স্ক্রিপ্টটিকে ধ্বংশ করে পুনরায় পেজটিকে রিলোড করার পরামর্শ দেয়। নিশ্চিতভাবে ব্যাপারটি ভালো না।
-For server-side JavaScript such a regexp may hang the server process, that's even worse. So we definitely should take a look at it.
+সার্ভার-সাইড জাভাস্ক্রিপ্টে এই ধরণের রেগুলার এক্সপ্রেশন সার্ভারের প্রসেস কে হ্যাং করে দেয়, যা আরো ভয়ানক! সুতরাং অবশ্যই আমাদের এই ব্যাপারটি জেনে রাখা উচিত..
-## Example
+## উদাহরণ
-Let's say we have a string, and we'd like to check if it consists of words `pattern:\w+` with an optional space `pattern:\s?` after each.
+মনে করুন আমাদের একটি স্ট্রিং আছে, এবং আমরা এটি শব্দ `pattern:\w+` দ্বারা গঠিত কিনা যাচাই করতে চাই সেই সাথে প্রতিটির শেষে অপশনাল স্পেস `pattern:\s?` আছে কিনা যাচাই করব।
-An obvious way to construct a regexp would be to take a word followed by an optional space `pattern:\w+\s?` and then repeat it with `*`.
+রেগুলার এক্সপ্রেশনে আমরা এটি সহজেই করতে পারি, একটি শব্দ নিয়ে তারপর একটি অপশনাল স্পেস `pattern:\w+\s?` এবং এটিকে বারবার পুনরাবৃত্তি করব `*` কোয়ান্টিফায়ারের সাহায্যে।
-That leads us to the regexp `pattern:^(\w+\s?)*$`, it specifies zero or more such words, that start at the beginning `pattern:^` and finish at the end `pattern:$` of the line.
+সুতরাং রেগুলার এক্সপ্রেশনটি হবে `pattern:^(\w+\s?)*$`, এটি দ্বারা যাচাই করা হচ্ছে লাইনের শুরুতে `pattern:^` এবং `pattern:$` শেষে শূন্য বা একাধিক শব্দ আছে কিনা।
-In action:
+যেমন:
```js run
let regexp = /^(\w+\s?)*$/;
@@ -25,59 +25,59 @@ alert( regexp.test("A good string") ); // true
alert( regexp.test("Bad characters: $@#") ); // false
```
-The regexp seems to work. The result is correct. Although, on certain strings it takes a lot of time. So long that JavaScript engine "hangs" with 100% CPU consumption.
+এটি কাজ করছে। রেজাল্টটিও সঠিকভাবে দেয়। তবে, কিছু নির্দিষ্ট স্ট্রিংয়ের জন্য এটি প্রচুর সময় নিবে। সুতরাং জাভাস্ক্রিপ্ট ইঞ্জিন ১০০% সিপিউ ব্যবহারের মাধ্যমে "হ্যাং" হয়ে যাবে।
-If you run the example below, you probably won't see anything, as JavaScript will just "hang". A web-browser will stop reacting on events, the UI will stop working (most browsers allow only scrolling). After some time it will suggest to reload the page. So be careful with this:
+যদি আপনি নিচের উদাহরণটি রান করান, হয়তো আপনি কিছু দেখবেন না, তবে জাভাস্ক্রিপ্ট "হ্যাং" হয়ে যাবে। ওয়েব ব্রাউজারের ইভেন্ট, ইউ আই কাজ করা বন্ধ করে দিবে(তবে কিছু ব্রাউজারের স্ক্রল কাজ করতে পারে)। এবং কিছু সময় পর এটি পুনরায় পেজটিকে রিলোড করার পরামর্শ দিবে। সুতরাং এই ব্যাপারটি আপনার জেনে রাখা উচিত:
```js run
let regexp = /^(\w+\s?)*$/;
let str = "An input string that takes a long time or even makes this regexp to hang!";
-// will take a very long time
+// এটি অনেক সময় নিবে
alert( regexp.test(str) );
```
-To be fair, let's note that some regular expression engines can handle such a search effectively. But most of them can't. Browser engines usually hang.
+কিছু রেগুলার এক্সপ্রেশন ইঞ্জিন এই ধরণের সার্চ করতে পারে, তবে বেশিরভাগই পারেনা। ব্রাউজার ইঞ্জিন সাধারণত হ্যাং হয়ে যায়।
-## Simplified example
+## উদাহরণকে সহজীকরণ
-What's the matter? Why the regular expression hangs?
+এখানে কি ঘটছে? কেন রেগুলার এক্সপ্রেশন ইঞ্জিন "হ্যাং" হয়?
-To understand that, let's simplify the example: remove spaces `pattern:\s?`. Then it becomes `pattern:^(\w+)*$`.
+এটি বুঝার জন্য, চলুন সহজ একটি উদাহরণ দেখি: স্পেসটি বাদ দেন `pattern:\s?`। সুতরাং এটি হবে `pattern:^(\w+)*$`।
-And, to make things more obvious, let's replace `pattern:\w` with `pattern:\d`. The resulting regular expression still hangs, for instance:
+এবং, ব্যাপারটিকে আরো সুস্পষ্ট করে তুলতে, `pattern:\w` এর পরিবর্তে `pattern:\d` ব্যবহার করি। রেজাল্টের জন্য রেগুলার এক্সপ্রেশন ইঞ্জিন হ্যাং থাকবে, যেমন:
```js run
let regexp = /^(\d+)*$/;
let str = "012345678901234567890123456789z";
-// will take a very long time (careful!)
+// এটি অনেক সময় নিবে (careful!)
alert( regexp.test(str) );
```
-So what's wrong with the regexp?
+এই রেগুলার এক্সপ্রেশনের ভুলটি কোথায়?
-First, one may notice that the regexp `pattern:(\d+)*` is a little bit strange. The quantifier `pattern:*` looks extraneous. If we want a number, we can use `pattern:\d+`.
+প্রথমত, আমরা লক্ষ্য করছি আমাদের প্যাটার্নটি `pattern:(\d+)*` কিছুটা অদ্ভুত। কোয়ান্টিফায়ারটি `pattern:*` এখানে অপ্রয়োজনীয় মনে হচ্ছে। যদি আমরা সংখ্যা চাই, আমরা `pattern:\d+` এটি ব্যবহার করতে পারি।
-Indeed, the regexp is artificial, we got it by simplifying the previous example. But the reason why it is slow is the same. So let's understand it, and then the previous example will become obvious.
+প্রকৃতপক্ষে, রেগুলার এক্সপ্রেশনটি আর্টিফিশিয়াল, পূর্বের উদাহরণে আমরা এটি দেখেছি। কিন্তু এটি কেন এত ধীরে কাজ করছে। চলুন আগে এটি বুঝি, এবং তারপর আমাদের কাছে উপরের উদাহরণটি আরো সুস্পষ্ট হবে।
-What happens during the search of `pattern:^(\d+)*$` in the line `subject:123456789z` (shortened a bit for clarity, please note a non-digit character `subject:z` at the end, it's important), why does it take so long?
+`subject:123456789z` এর মধ্যে `pattern:^(\d+)*$` এর দ্বারা অনুসন্ধানে কি ঘটে(সংক্ষিপ্তরূপটি আমাদের বুঝার সুবিধার্তে শেষে আমরা একটি অঙ্ক নয় এমন একটি ক্যারাক্টার `subject:z` সবার শেষে রেখেছি), কেন এটি এত সময় নেয়?
-Here's what the regexp engine does:
+এখানে রেগুলার এক্সপ্রেশন ইঞ্জিন কিভাবে কাজ করছে:
-1. First, the regexp engine tries to find the content of the parentheses: the number `pattern:\d+`. The plus `pattern:+` is greedy by default, so it consumes all digits:
+১. প্রথমত, রেগুলার এক্সপ্রেশনটি প্যারেন্টেসিসের অংশটি একটি সংখ্যা `pattern:\d+` অনুসন্ধান করে। কোয়ান্টিফায়ারটি `pattern:+` ডিফল্টভাবে গ্রীডি, সুতরাং এটি সকল অঙ্ক নিবে:
```
\d+.......
(123456789)z
```
- After all digits are consumed, `pattern:\d+` is considered found (as `match:123456789`).
-
- Then the star quantifier `pattern:(\d+)*` applies. But there are no more digits in the text, so the star doesn't give anything.
+ সকল অঙ্ক নেয়ার পর, `pattern:\d+` অনুসন্ধানকৃত মানটি (`match:123456789`)।
- The next character in the pattern is the string end `pattern:$`. But in the text we have `subject:z` instead, so there's no match:
+ এরপর এটি `pattern:(\d+)*` কোয়ান্টিফায়ার প্রয়োগ করবে, কিন্ত এখানে আর কোন অঙ্ক নেই, সুতরাং * কোন কিছু দিবে না।
+
+ প্যাটার্নের শেষ অংশটি হল `pattern:$`, কিন্তু স্ট্রিংয়ের শেষ ক্যারাক্টারটি হল `subject:z`, সুতরাং এখানে কোন মিল পাবে না:
```
X
@@ -85,16 +85,16 @@ Here's what the regexp engine does:
(123456789)z
```
-2. As there's no match, the greedy quantifier `pattern:+` decreases the count of repetitions, backtracks one character back.
+২. যেহেতু কোন মিল খুঁজে পাবে না, গ্রীডি কোয়ান্টিফায়ার `pattern:+` সুতরাং এটি আবার ক্যারাক্টারকে কমাতে থাকবে, সুতরাং এর অবস্থানটি পূর্ববর্তী ক্যারাক্টারে আসবে।
- Now `pattern:\d+` takes all digits except the last one (`match:12345678`):
+ এখন `pattern:\d+` শেষ ক্যারাক্টারটি বাদে সকল ক্যারাক্টার নিবে (`match:12345678`):
```
\d+.......
(12345678)9z
```
-3. Then the engine tries to continue the search from the next position (right after `match:12345678`).
+৩. অতঃপর ইঞ্জিন পরবর্তী অবস্থান (`match:12345678`) থেকে পুনরায় অনুসন্ধান চালাবে।
- The star `pattern:(\d+)*` can be applied -- it gives one more match of `pattern:\d+`, the number `match:9`:
+ `pattern:(\d+)*` কোয়ান্টিফায়ারটি আবার প্রয়োগ হবে -- এটি আরো একটি সংখ্যার `pattern:\d+` সাথে মিলে, সংখ্যাটি `match:9`:
```
@@ -102,7 +102,7 @@ Here's what the regexp engine does:
(12345678)(9)z
```
- The engine tries to match `pattern:$` again, but fails, because it meets `subject:z` instead:
+ ইঞ্জিন প্যাটার্নের `pattern:$` শেষ অংশটি আবার মিলাতে চেষ্টা করে, কিন্তু আবারো মিলবে না, কেননা শেষ ক্যারাক্টারটি হল `subject:z`:
```
X
@@ -111,11 +111,11 @@ Here's what the regexp engine does:
```
-4. There's no match, so the engine will continue backtracking, decreasing the number of repetitions. Backtracking generally works like this: the last greedy quantifier decreases the number of repetitions until it can. Then the previous greedy quantifier decreases, and so on.
+৪. আবারো কোন মিল খুঁজে পাবে না, সুতরাং ইঞ্জিন আবারো ব্যাকট্রাকিং চালাবে, এবং সংখ্যার পুনরাবৃত্তি কমাবে। ব্যাকট্রাকিং সাধারণত এভাবে কাজ করে: শেষ গ্রীডি কোয়ান্টিফায়ার যত সম্ভব সংখ্যার পুনরাবৃত্তি কমাবে। তারপর এর পূর্ববর্তী কোয়ান্টিফায়ারের জন্য কমাবে, এভাবেই চলতে থাকে।
- All possible combinations are attempted. Here are their examples.
+ সকল সম্ভাব্যতা যাচাইয়ের চেষ্টা করবে। যেমন:
- The first number `pattern:\d+` has 7 digits, and then a number of 2 digits:
+ প্রথম সংখ্যাটিতে `pattern:\d+` ৭টি অঙ্ক আছে, এবং পরবর্তী সংখ্যাটিতে ২টি অঙ্ক আছে:
```
X
@@ -123,7 +123,7 @@ Here's what the regexp engine does:
(1234567)(89)z
```
- The first number has 7 digits, and then two numbers of 1 digit each:
+ প্রথম সংখ্যাটিতে `pattern:\d+` ৭টি অঙ্ক আছে, এবং পরবর্তী ২টি সংখ্যাতে ১টি করে অঙ্ক আছে:
```
X
@@ -131,7 +131,7 @@ Here's what the regexp engine does:
(1234567)(8)(9)z
```
- The first number has 6 digits, and then a number of 3 digits:
+ প্রথম সংখ্যাটিতে `pattern:\d+` ৬টি অঙ্ক আছে, এবং পরবর্তী সংখ্যাতে ৩টি অঙ্ক আছে:
```
X
@@ -139,7 +139,7 @@ Here's what the regexp engine does:
(123456)(789)z
```
- The first number has 6 digits, and then 2 numbers:
+ প্রথম সংখ্যাটিতে `pattern:\d+` ৭টি অঙ্ক আছে, এবং পরবর্তী ২টি সংখ্যাতে ২টি এবং ১টি করে অঙ্ক আছে:
```
X
@@ -147,22 +147,22 @@ Here's what the regexp engine does:
(123456)(78)(9)z
```
- ...And so on.
+ ...এভাবেই চলতে থাকে।
-There are many ways to split a sequence of digits `123456789` into numbers. To be precise, there are <code>2<sup>n</sup>-1</code>, where `n` is the length of the sequence.
+এখানে `123456789` অঙ্কগুলোকে বিভিন্ন উপায়ে সাজানোর পদ্ধতি আছে। মোট উপায়টি হল, <code>2<sup>n</sup>-1</code>, যেখানে `n` হল সেটটির অঙ্কের সংখ্যা।
-- For `123456789` we have `n=9`, that gives 511 combinations.
-- For a longer sequence with `n=20` there are about one million (1048575) combinations.
-- For `n=30` - a thousand times more (1073741823 combinations).
+- `123456789` এ `n=9`, এর মোট ৫১১টি কম্বিনেশন আছে।
+- আরো বড় সিক্যুয়েন্সের জন্য `n=20` মোট ১০৪৮৫৭৫ টি কম্বিনেশন আছে।
+- `n=30` এর জন্য - আরো হাজার গুণ (১০৭৩৭৪১৮২৩ টি কম্বিনেশন)।
-Trying each of them is exactly the reason why the search takes so long.
+ইঞ্জিন প্রতিটি কম্বিনেশন মেলাতে চেষ্টা করে, তাই এটি এত সময় নেয়।
-## Back to words and strings
+## পুনরায় শব্দ এবং স্ট্রিং
-The similar thing happens in our first example, when we look words by pattern `pattern:^(\w+\s?)*$` in the string `subject:An input that hangs!`.
+একই ব্যাপারটি ঘটে আমাদের প্রথম উদাহরণে, যখন আমরা প্যাটার্নটি দ্বারা `pattern:^(\w+\s?)*$` স্ট্রিংয়ে `subject:An input that hangs!` শব্দের অনুসন্ধান চালায়।
-The reason is that a word can be represented as one `pattern:\w+` or many:
+কেননা আমরা শব্দকে `pattern:\w+` এক বা একাধিক উপায়ে প্রকাশ করতে পারি:
```
(input)
@@ -172,27 +172,27 @@ The reason is that a word can be represented as one `pattern:\w+` or many:
...
```
-For a human, it's obvious that there may be no match, because the string ends with an exclamation sign `!`, but the regular expression expects a wordly character `pattern:\w` or a space `pattern:\s` at the end. But the engine doesn't know that.
+একজন মানুষ সহজেই বুঝতে পারে এখানে কোন মিল নেই, কেননা স্ট্রিংটি একটি আশ্চর্যবোধক চিহ্ন দ্বারা `!` শেষ হয়, কিন্তু আমাদের প্যাটার্নটি সবার শেষে `pattern:\w` একটি বর্ণ বা স্পেস `pattern:\s` খুঁজে। কিন্ত ইঞ্জিন এটি বুঝতে পারেনা।
-It tries all combinations of how the regexp `pattern:(\w+\s?)*` can "consume" the string, including variants with spaces `pattern:(\w+\s)*` and without them `pattern:(\w+)*` (because spaces `pattern:\s?` are optional). As there are many such combinations (we've seen it with digits), the search takes a lot of time.
+`pattern:(\w+\s?)*` এই প্যাটার্নটি স্ট্রিংয়ের সকল সম্ভাব্যতা এমনকি স্পেসসহ `pattern:(\w+\s)*` এবং স্পেসছাড়া `pattern:(\w+)*` সবকে যাচাই করে(কেননা স্পেস হল `pattern:\s?` অপশনাল)। এখানে অনেক কম্বিনেশন আছে(সংখ্যার উদাহরণে আমরা দেখেছি), এরা প্রচুর সময় নেয়।
-What to do?
+এক্ষেত্রে আমরা কি করতে পারি?
-Should we turn on the lazy mode?
+আমরা কি লেজি মোডে অনুসন্ধান করব?
-Unfortunately, that won't help: if we replace `pattern:\w+` with `pattern:\w+?`, the regexp will still hang. The order of combinations will change, but not their total count.
+দুর্ভাগ্যবশত, এটি কাজ করবে না: যদি আমরা `pattern:\d+` এর পরিবর্তে `pattern:\d+?` ব্যবহার করি, তাও রেগুলার এক্সপ্রেশন ইঞ্জিন হ্যাং হয়ে যাবে। কম্বিনেশন পরিবর্তন হবে, কিন্তু সম্পূর্ন সংখ্যার পরিবর্তন হবে না।
-Some regular expression engines have tricky tests and finite automations that allow to avoid going through all combinations or make it much faster, but most engines don't, and it doesn't always help.
+কিছু রেগুলার এক্সপ্রেশন ইঞ্জিন কৌশলে সসীম অটোমেশন যাচাই করে, যাতে সকল কম্বিনেশন যাচাই করতে না হয়, এর ফলে এরা কিছুটা দ্রুত কাজ করে, কিন্তু সকল ইঞ্জিন সকল টেস্টের জন্য এভাবে যাচাই করতে পারে না।
-## How to fix?
+## কিভাবে সমাধান করতে পারি?
-There are two main approaches to fixing the problem.
+সমস্যাটি সমাধানের দুটি পদ্ধতি আছে।
-The first is to lower the number of possible combinations.
+প্রথমটি হল আমরা যথাযথ সম্ভব কম্বিনেশনকে কমাব।
-Let's make the space non-optional by rewriting the regular expression as `pattern:^(\w+\s)*\w*$` - we'll look for any number of words followed by a space `pattern:(\w+\s)*`, and then (optionally) a final word `pattern:\w*`.
+চলুন প্যাটার্নটি আবার লিখি `pattern:^(\w+\s)*\w*` - প্রথমে আমরা খুঁজব শব্দের শেষে কোন স্পেস আছে কিনা `pattern:(\w+\s)*`, এবং সর্বশেষে একটি(অপশনাল) শব্দ `pattern:\w*`।
-This regexp is equivalent to the previous one (matches the same) and works well:
+এই প্যাটার্নটি পূর্বের মত(একই মিল খুঁজে) এবং এটি ভালোভাবে কাজ করে:
```js run
let regexp = /^(\w+\s)*\w*$/;
@@ -201,34 +201,34 @@ let str = "An input string that takes a long time or even makes this regex to ha
alert( regexp.test(str) ); // false
```
-Why did the problem disappear?
+সমস্যাটি কিভাবে দূরীভূত হল?
-That's because now the space is mandatory.
+কেননা এখন স্পেসটি বাধ্যতামূলক।
-The previous regexp, if we omit the space, becomes `pattern:(\w+)*`, leading to many combinations of `\w+` within a single word
+পূর্ববর্তী রেগুলার এক্সপ্রেশনে, যদি আমরা স্পেসটি বাদ দেই এটি হবে এমন `pattern:(\w+)*`, যা দ্বারা একটি শব্দের একাধিক `\w+` কম্বিনেশন হবে।
-So `subject:input` could be matched as two repetitions of `pattern:\w+`, like this:
+সুতরাং `subject:input` এটি পুনরাবৃত্তির সময় `pattern:\w+` দুইবার মিলবে, যেমন:
```
\w+ \w+
(inp)(ut)
```
-The new pattern is different: `pattern:(\w+\s)*` specifies repetitions of words followed by a space! The `subject:input` string can't be matched as two repetitions of `pattern:\w+\s`, because the space is mandatory.
+কিন্ত আমাদের নতুন প্যাটার্নটিতে আমরা স্পেস দ্বারা শব্দকে নির্দিষ্ট করে দিচ্ছি: `pattern:(\w+\s)*`! `subject:input` স্ট্রিংটি দ্বিতীয়বার পুনরাবৃত্তিতে মিলবে না `pattern:\w+\s`, কেননা এখন স্পেসটি বাধ্যতামূলক।
-The time needed to try a lot of (actually most of) combinations is now saved.
+এর সাহায্যে আমরা একাধিক অপ্রয়োজনীয় কম্বিনেশন কে এড়াতে পারি।
-## Preventing backtracking
+## প্রিভেন্ট ব্যাকট্রাকিং
-It's not always convenient to rewrite a regexp though. In the example above it was easy, but it's not always obvious how to do it.
+পুনরায় রেগুলার এক্সপ্রেশন লিখা সবসময় সহজ নয়। উপরের উদাহরণে এটি পরিবর্তন করা সহজ ছিল, কিন্তু সবসময় আমাদের কাছে এটি সহজবোধ্য থাকে না।
-Besides, a rewritten regexp is usually more complex, and that's not good. Regexps are complex enough without extra efforts.
+এছাড়াও, পুনরায় লিখিত রেগুলার এক্সপ্রেশন আরো জটিল হয়, এবং এটি ভালোও না। এমনিতেও রেগুলার এক্সপ্রেশনসমূহ যথেষ্ট জটিল।
-Luckily, there's an alternative approach. We can forbid backtracking for the quantifier.
+তবে, আমাদের কাছে আরো একটি উপায় আছে। যার মাধ্যমে আমরা কোয়ান্টিফায়ারের জন্য ব্যাকট্রাকিং কে বাধা দিতে পারি।
-The root of the problem is that the regexp engine tries many combinations that are obviously wrong for a human.
+তবে রেগুলার এক্সপ্রেশন ইঞ্জিন এমন সব সম্ভাব্যতা নিয়ে চেষ্টা করে, কম্বিনেশনগুলো ভুল তা মানুষ সহজেই বুঝতে পারে।
-E.g. in the regexp `pattern:(\d+)*$` it's obvious for a human, that `pattern:+` shouldn't backtrack. If we replace one `pattern:\d+` with two separate `pattern:\d+\d+`, nothing changes:
+যেমন রেগুলার এক্সপ্রেশনটি `pattern:(\d+)*$` প্রোগ্রামারদের কাছে সুষ্পষ্ট, এটির `pattern:+` ব্যাকট্রাকিং করা উচিত নয়। যদি আমরা এটিকে `pattern:\d+` দুটি `pattern:\d+\d+` প্যাটার্নে বিভক্ত করি, তারপরও কোন পরিবর্তন হবে না:
```
\d+........
@@ -238,55 +238,55 @@ E.g. in the regexp `pattern:(\d+)*$` it's obvious for a human, that `pattern:+`
(1234)(56789)!
```
-And in the original example `pattern:^(\w+\s?)*$` we may want to forbid backtracking in `pattern:\w+`. That is: `pattern:\w+` should match a whole word, with the maximal possible length. There's no need to lower the repetitions count in `pattern:\w+`, try to split it into two words `pattern:\w+\w+` and so on.
+এবং আমাদের মূল উদাহারণটিতে `pattern:^(\w+\s?)*$` আমরা চাই ব্যাকট্রাকিংকে বাদ দিতে `pattern:\w+`। সুতরাং: `pattern:\w+` এটি সম্ভাব্য পুরো শব্দের সাথে মিলবে। পুনরাবৃত্তি কে না কমিয়ে আমরা `pattern:\w+` কে `pattern:\w+\w+` দুটি শব্দে বিভক্ত করতে পারি।
-Modern regular expression engines support possessive quantifiers for that. Regular quantifiers become possessive if we add `pattern:+` after them. That is, we use `pattern:\d++` instead of `pattern:\d+` to stop `pattern:+` from backtracking.
+আধুনিক রেগুলার এক্সপ্রেশ ইঞ্জিন গুলো পসেসিভ কোয়ান্টিফায়ার সমর্থন করে। পসেসিভের কোয়ান্টিফায়ারের জন্য কোয়ান্টিফায়ারের পরে `pattern:+` যোগ করলে হবে। ব্যাকট্রাকিংকে থামাতে আমরা `pattern:\d+` এর বদলে `pattern:\d++` লিখব।
-Possessive quantifiers are in fact simpler than "regular" ones. They just match as many as they can, without any backtracking. The search process without bracktracking is simpler.
+পসেসিভের কোয়ান্টিফায়ার সমূহ আরো সহজ। এরা ব্যাকট্রাকিং ছাড়া যতটা সম্ভব মেলাতে চেষ্টা করে। ব্যাকট্রাকিং ছাড়া এই অনুসন্ধানটি আরো সহজবোধ্য।
-There are also so-called "atomic capturing groups" - a way to disable backtracking inside parentheses.
+এদেরকে "এটমিক ক্যাপচারিং গ্রুপও" বলা হয় - প্যারেন্টেসিসের ভিতর ব্যাকট্রাকিংয় রোধের একটি উপায়।
-...But the bad news is that, unfortunately, in JavaScript they are not supported.
+...কিন্তু দুর্ভাগ্যবশত, জাভাস্ক্রিপ্টে এটি সাপোর্ট করে না।
-We can emulate them though using a "lookahead transform".
+তবে লুকঅ্যাহেডের মাধ্যমে আমরা অনূরূপ কাজ করতে পারি।
### Lookahead to the rescue!
-So we've come to real advanced topics. We'd like a quantifier, such as `pattern:+` not to backtrack, because sometimes backtracking makes no sense.
+এখন আমরা আমাদের মূল সমস্যাটির আলোচনা করব। আমরা এমন একটি কোয়ান্টিফায়ার চাই, যেমন `pattern:+` যেন ব্যাকট্রাক না করে, কেননা অনেক সময় ব্যাকট্রাকিং কাজে আসে না।
-The pattern to take as much repetitions of `pattern:\w` as possible without backtracking is: `pattern:(?=(\w+))\1`. Of course, we could take another pattern instead of `pattern:\w`.
+`pattern:(?=(\w+))\1` প্যাটার্নটি ব্যাকট্রাকিং ছাড়াই সর্বোচ্চ সংখ্যক `pattern:\w` পুনরাবৃত্তিকে ক্যাপচার করে। অবশ্য, আমরা `pattern:\w` এর পরিবর্তে অন্যান্য প্যাটার্নও নিতে পারি।
-That may seem odd, but it's actually a very simple transform.
+এটি দেখতে যদিও বিদঘুটে, কিন্তু আসলেই এটি সাধারণ একটি পরিবর্তন।
-Let's decipher it:
+চলুন প্যাটার্নটি বুঝার চেষ্টা করি:
-- Lookahead `pattern:?=` looks forward for the longest word `pattern:\w+` starting at the current position.
-- The contents of parentheses with `pattern:?=...` isn't memorized by the engine, so wrap `pattern:\w+` into parentheses. Then the engine will memorize their contents
-- ...And allow us to reference it in the pattern as `pattern:\1`.
+- লুকঅ্যাহেড `pattern:?=` বর্তমান পজিশন থেকে সবচেয়ে দীর্ঘ শব্দটি `pattern:\w+` খুঁজে।
+- প্যারেন্টেসিসের `pattern:?=...` ভিতরের কন্টেন্ট `pattern:?=...` ইঞ্জিন সংরক্ষণ করে না, সুতরাং আমরা `pattern:\w+` কে আরো একটি প্যারেন্টেসিসের মধ্যে রাখি। এখন ইঞ্জিন কন্টেন্টসমূহকে সংরক্ষণ করে
+- ...এবং আমরা একে প্যাটার্নে রেফারেন্স হিসেবে ব্যবহার করি `pattern:\1`।
-That is: we look ahead - and if there's a word `pattern:\w+`, then match it as `pattern:\1`.
+অর্থাৎ: আমরা পরবর্তী ক্যারাক্টারগুলো দেখছি এবং যদি কোন শব্দ `pattern:\w+` থাকে, তারপর `pattern:\1` এটির সাথে মিলবে।
-Why? That's because the lookahead finds a word `pattern:\w+` as a whole and we capture it into the pattern with `pattern:\1`. So we essentially implemented a possessive plus `pattern:+` quantifier. It captures only the whole word `pattern:\w+`, not a part of it.
+কেন? কেননা লুকঅ্যাহেড সম্পূর্ন শব্দকে `pattern:\w+` খুঁজে এবং আমরা এটিকে প্যাটার্নে ক্যাপচার করি `pattern:\1`। এটি দ্বারা আসলে আমরা পসেসিভ কোয়ান্টিফায়ারকে `pattern:+` বাস্তবায়িত করছি। এটি দ্বারা কোন একটি অংশ ক্যাপচার না হয়ে সম্পূর্ন শব্দটি ক্যাপচার হচ্ছে `pattern:\w+`।
-For instance, in the word `subject:JavaScript` it may not only match `match:Java`, but leave out `match:Script` to match the rest of the pattern.
+যেমন, `subject:JavaScript` এই শব্দটি কেবল `match:Java` এর সাথে ম্যাচ করবে না, এবং বাকী প্যাটার্নের `match:Script` সাথে মিল খুঁজে বাদ দেয়।
-Here's the comparison of two patterns:
+এখানে প্যাটার্ন দুটির তুলনা দেখুন:
```js run
alert( "JavaScript".match(/\w+Script/)); // JavaScript
alert( "JavaScript".match(/(?=(\w+))\1Script/)); // null
```
-1. In the first variant `pattern:\w+` first captures the whole word `subject:JavaScript` but then `pattern:+` backtracks character by character, to try to match the rest of the pattern, until it finally succeeds (when `pattern:\w+` matches `match:Java`).
-2. In the second variant `pattern:(?=(\w+))` looks ahead and finds the word `subject:JavaScript`, that is included into the pattern as a whole by `pattern:\1`, so there remains no way to find `subject:Script` after it.
+1. প্রথম প্যাটার্নটিতে `pattern:\w+` প্রথমে সম্পুর্ন শব্দটি `subject:JavaScript` ক্যাপচার করে এবং তারপর `pattern:+` ব্যাকট্রাকিং করে শেষ হতে, এবং বাকী প্যাটার্নটি মেলানোর চেষ্টা করে, এবং শেষ পর্যন্ত মিলে যায় (যখন `pattern:\w+` প্যাটার্নটি `match:Java` এর সাথে মিলে)।
+2. দ্বিতীয় লুকঅ্যাহেড প্যাটার্নটি `pattern:(?=(\w+))` শব্দটি `subject:JavaScript` খুঁজে, এবং এটিও প্যাটার্নে `pattern:\1` সংযুক্ত হয়, সুতরাং এর পরে আর `subject:Script` খুঁজে পায় না।
-We can put a more complex regular expression into `pattern:(?=(\w+))\1` instead of `pattern:\w`, when we need to forbid backtracking for `pattern:+` after it.
+আমরা `pattern:(?=(\w+))\1` এই প্যাটার্নে `pattern:\w` এর পরিবর্তে আরো জটিল এক্সপ্রেশন রাখতে পারি, যদি আমরা `pattern:+` এর ব্যাকট্রাকিং রোধ করতে চায়।
```smart
-There's more about the relation between possessive quantifiers and lookahead in articles [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) and [Mimicking Atomic Groups](http://blog.stevenlevithan.com/archives/mimic-atomic-groups).
+পসেসিভ কোয়ান্টফায়ার এবং লুকঅ্যাহেড সম্পর্কে আরো বিস্তারিত জানতে এই আর্টিকেলগুলো দেখুন [Regex: Emulate Atomic Grouping (and Possessive Quantifiers) with LookAhead](http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead) এবং [Mimicking Atomic Groups](http://blog.stevenlevithan.com/archives/mimic-atomic-groups)।
```
-Let's rewrite the first example using lookahead to prevent backtracking:
+চলুন আমাদের প্রথম উদাহরণটি লুকঅ্যাহেড এর সাহায্যে আবার লিখি যা ব্যাকট্রাকিং রোধ করে:
```js run
let regexp = /^((?=(\w+))\2\s?)*$/;
@@ -295,10 +295,10 @@ alert( regexp.test("A good string") ); // true
let str = "An input string that takes a long time or even makes this regex to hang!";
-alert( regexp.test(str) ); // false, works and fast!
+alert( regexp.test(str) ); // ভুল, এবং দ্রুত কাজ করছে!
```
-Here `pattern:\2` is used instead of `pattern:\1`, because there are additional outer parentheses. To avoid messing up with the numbers, we can give the parentheses a name, e.g. `pattern:(?<word>\w+)`.
+এখানে আমরা এর `pattern:\1` পরিবর্তে `pattern:\2` ব্যবহার করেছি, কেননা এখানে আরো একটি অতিরিক্ত একটি প্যারেন্টেসিস আছে। ক্রমের ঝামেলা এড়াতে আমরা গ্রুপের নাম দিতে পারি, যেমন `pattern:(?<word>\w+)`।
```js run
// parentheses are named ?<word>, referenced as \k<word>
@@ -311,8 +311,8 @@ alert( regexp.test(str) ); // false
alert( regexp.test("A correct string") ); // true
```
-The problem described in this article is called "catastrophic backtracking".
+এই আর্টিকেলে বর্ণিত সমস্যাটিকে বলা হয় "catastrophic backtracking"।
-We covered two ways how to solve it:
-- Rewrite the regexp to lower the possible combinations count.
-- Prevent backtracking.
+আমরা এখানে দুটি উপায় দেখেছি কিভাবে সমস্যাটি সমাধান করা যায়:
+- রেগুলার এক্সপ্রেশন পুনরায় লিখে কম্বিনেশনের সংখ্যা কমানো।
+- প্রিভেন্ট ব্যাকট্রাকিং।