From e062fd0cb2b1531495c8bb7f0949a78e7355d395 Mon Sep 17 00:00:00 2001
From: Saiful <msisaifulsaif@gmail.com>
Date: Sun, 17 Jan 2021 16:26:06 +0600
Subject: [PATCH 1/3] translate article

---
 .../14-regexp-lookahead-lookbehind/article.md | 107 +++++++++---------
 1 file changed, 54 insertions(+), 53 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 31393cd03..af1f6460b 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,39 +1,39 @@
-# Lookahead and lookbehind
+# লুকঅ্যাহেড এবং লুকবিহাইন্ড
 
-Sometimes we need to find only those matches for a pattern that are followed or preceeded by another pattern.
+অনেক সময় আমাদের এমন প্যাটার্ন খুঁজা লাগে যা অন্য প্যাটার্নের উপর নির্ভর করে।
 
-There's a special syntax for that, called "lookahead" and "lookbehind", together referred to as "lookaround".
+এজন্য রেগুলার এক্সপ্রেশনে একটি বিশেষ সিনট্যাক্স আছে "লুকঅ্যাহেড" এবং "লুকবিহাইন্ড", এদের একত্রে বলা হয়  "লুকঅ্যারাউন্ড"।
 
-For the start, let's find the price from the string like `subject:1 turkey costs 30€`. That is: a number, followed by `subject:€` sign.
+চলুন একটি ব্যবহারিক উদাহরণ দেখি, `subject:1 turkey costs 30€` এ স্ট্রিং হতে আমরা দাম খুঁজে বের করব। প্যাটার্নটি হবে প্রথমে একটি `subject:€` চিহ্ন তারপর একটি সংখ্যা।
 
-## Lookahead
+## লুকঅ্যাহেড
 
-The syntax is: `pattern:X(?=Y)`, it means "look for `pattern:X`, but match only if followed by `pattern:Y`". There may be any pattern instead of `pattern:X` and `pattern:Y`.
+সিনট্যাক্সটি হবে: `pattern:X(?=Y)`, এটি দ্বারা বুঝায় এর সাথে মিলবে `pattern:X`, কেবলমাত্র এটি যদি `pattern:Y` দ্বারা শুরু হয়। `pattern:X` এবং `pattern:Y` এর পরিবর্তে যেকোন প্যাটার্ন হতে পারে।
 
-For an integer number followed by `subject:€`, the regexp will be `pattern:\d+(?=€)`:
+`subject:€` পর একটি পূর্ণ সংখ্যা হবে, সুতরাং রেগুলার এক্সপ্রেশনটি হবে `pattern:\d+(?=€)`:
 
 ```js run
 let str = "1 turkey costs 30€";
 
-alert( str.match(/\d+(?=€)/) ); // 30, the number 1 is ignored, as it's not followed by €
+alert( str.match(/\d+(?=€)/) ); // 30, 1 এর সাথে মিল হবে না কেননা এর পূর্বে € নাই
 ```
 
-Please note: the lookahead is merely a test, the contents of the parentheses `pattern:(?=...)` is not included in the result `match:30`.
+লক্ষ্য করুন: লুকঅ্যাহেড হল একটি যাচাই পদ্ধতি, প্যারেন্টেসিসের কন্টেন্ট `pattern:(?=...)` রেজাল্টের মধ্যে আসবে না অর্থাৎ রেজাল্ট হবে `match:30`।
 
-When we look for `pattern:X(?=Y)`, the regular expression engine finds `pattern:X` and then checks if there's `pattern:Y` immediately after it. If it's not so, then the potential match is skipped, and the search continues.
+চলুন `pattern:X(?=Y)` কিভাবে কাজ করছে তা বোঝার চেষ্টা করি, রেগুলার এক্সপ্রেশন ইঞ্জিন প্রথমে খুঁজবে `pattern:X` এবং এরপর খুঁজবে `pattern:Y` আছে কিনা। যদি এটি না মেলে, তাহলে ঐ মিলগুলো বাদ দিবে, এবং অনুসন্ধান চালিয়ে যাবে।
 
-More complex tests are possible, e.g. `pattern:X(?=Y)(?=Z)` means:
+আমরা আরো জটিল অনুসন্ধানও চালাতে পারি, যেমন `pattern:X(?=Y)(?=Z)` দ্বারা বুঝায়:
 
-1. Find `pattern:X`.
-2. Check if `pattern:Y` is immediately after `pattern:X` (skip if isn't).
-3. Check if `pattern:Z` is immediately after `pattern:X` (skip if isn't).
-4. If both tests passed, then it's the match.
+১. প্রথমে `pattern:X` খুঁজবে।
+২. পরবর্তী অনুসন্ধান চালাবে যদি `pattern:X` এরপর `pattern:Y` থাকে(অন্যথায় বাদ যাবে)।
+৩. পরবর্তী অনুসন্ধান চালাবে যদি `pattern:X` এরপর `pattern:Z` থাকে(অন্যথায় বাদ যাবে)।
+৪. যদি উভয়ই অনুসন্ধান মিলে, তাহলে `pattern:X` রেজাল্ট দেখাবে।
 
-In other words, such pattern means that we're looking for `pattern:X` followed by   `pattern:Y` and `pattern:Z` at the same time.
+অন্য কথায় বলা যায়, আমরা `pattern:X` কে এমনভাবে খুঁজছি যার পরে `pattern:Y` এবং `pattern:Z` থাকবে।
 
-That's only possible if patterns `pattern:Y` and `pattern:Z` aren't mutually exclusive.
+এটি অবশ্যই সম্ভব হবে যদি `pattern:Y` এবং `pattern:Z` পরস্পর সাংঘর্ষিক না হয়।
 
-For example, `pattern:\d+(?=\s)(?=.*30)` looks for `pattern:\d+` only if it's followed by a space, and there's `30` somewhere after it:
+যেমন, `pattern:\d+(?=\s)(?=.*30)` দ্বারা বুঝায় `pattern:\d+` এরপর একটি স্পেস থাকবে, এবং তারপর যেকোন অবস্থানে `30` থাকবে:
 
 ```js run
 let str = "1 turkey costs 30€";
@@ -41,67 +41,67 @@ let str = "1 turkey costs 30€";
 alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 ```
 
-In our string that exactly matches the number `1`.
+এক্ষেত্রে আমাদের প্রাপ্ত ফলাফলটি হবে `1`।
 
-## Negative lookahead
+## নেগেটিভ লুকঅ্যাহেড
 
-Let's say that we want a quantity instead, not a price from the same string. That's a number `pattern:\d+`, NOT followed by `subject:€`.
+চলুন আমরা দামের বদলে পরিমাণ খুঁজে বের করি। সুতরাং সংখ্যাটি হবে `pattern:\d+` যার পরে `subject:€` থাকবে না।
 
-For that, a negative lookahead can be applied.
+এজন্য আমরা, নেগেটিভ লুকঅ্যাহেড এর সাহায্য নিতে পারি।
 
-The syntax is: `pattern:X(?!Y)`, it means "search `pattern:X`, but only if not followed by `pattern:Y`".
+সিনট্যাক্সটি হবে: `pattern:X(?!Y)`, এটি দ্বারা বুঝায় "`pattern:X` কে খুঁজবে, কেবলমাত্র এরপর যদি `pattern:Y` না থাকে"।
 
 ```js run
 let str = "2 turkeys cost 60€";
 
-alert( str.match(/\d+(?!€)/) ); // 2 (the price is skipped)
+alert( str.match(/\d+(?!€)/) ); // 2 (দামকে বাদ দেয়া হয়েছে)
 ```
 
-## Lookbehind
+## লুকবিহাইন্ড
 
-Lookahead allows to add a condition for "what follows".
+লুকঅ্যাহেড একটি শর্ত আরোপ করে "পরবর্তী অবস্থান"।
 
-Lookbehind is similar, but it looks behind. That is, it allows to match a pattern only if there's something before it.
+লুকবিহাইন্ড ও অনুরূপ, কিন্তু এটি পূর্বের অবস্থান খুঁজে। অর্থাৎ এটি মিলবে কেবল প্যাটার্নের পূর্বের কোন একটি প্যাটার্নের সাথে মিললে।
 
-The syntax is:
-- Positive lookbehind: `pattern:(?<=Y)X`, matches `pattern:X`, but only if there's  `pattern:Y` before it.
-- Negative lookbehind: `pattern:(?<!Y)X`, matches `pattern:X`, but only if there's no `pattern:Y` before it.
+সিনট্যাক্সটি হবে:
+- পজেটিভ লুকবিহাইন্ড: `pattern:(?<=Y)X`, `pattern:X` মিলবে, কেবল এরপূর্বে যদি  `pattern:Y` থাকে।
+- নেগেটিভ লুকবিহাইন্ড: `pattern:(?<!Y)X`, `pattern:X` মিলবে, কেবল এরপূর্বে যদি  `pattern:Y` না থাকে।
 
-For example, let's change the price to US dollars. The dollar sign is usually before the number, so to look for `$30` we'll use `pattern:(?<=\$)\d+` -- an amount preceded by `subject:$`:
+যেমন, চলুন আমরা দামটিকে US ডলার চিহ্ন দ্বারা প্রকাশ করি। ডলার চিহ্ন সাধারণত সংখ্যার পূর্বে থাকে, সুতরাং `$30` এটি খুঁজতে আমাদের প্যাটার্নটি হবে `pattern:(?<=\$)\d+` -- দামের পূর্বে একটি `subject:$` চিহ্ন:
 
 ```js run
 let str = "1 turkey costs $30";
 
-// the dollar sign is escaped \$
-alert( str.match(/(?<=\$)\d+/) ); // 30 (skipped the sole number)
+// রেজাল্টে ডলার চিহ্নটি আসবে না \$
+alert( str.match(/(?<=\$)\d+/) ); // 30 (পরিমাণটি বাদ যাবে)
 ```
 
-And, if we need the quantity -- a number, not preceded by `subject:$`, then we can use a negative lookbehind `pattern:(?<!\$)\d+`:
+এবং আমাদের যদি পরিমাণটি লাগে, অর্থাৎ আর পূর্বে `subject:$` থাকবে না, এজন্য আমরা নেগেটিভ লুকবিহাইন্ড ব্যবহার করতে পারব `pattern:(?<!\$)\d+`:
 
 ```js run
 let str = "2 turkeys cost $60";
 
-alert( str.match(/(?<!\$)\d+/) ); // 2 (skipped the price)
+alert( str.match(/(?<!\$)\d+/) ); // 2 (দাম বাদ যাবে)
 ```
 
-## Capturing groups
+## ক্যাপচারিং গ্রুপ
 
-Generally, the contents inside lookaround parentheses does not become a part of the result.
+সাধারণত, লুকঅ্যারাউন্ড এর প্যারেন্টেসিস এর কন্টেন্টগুলো রেজাল্টে আসেনা।
 
-E.g. in the pattern `pattern:\d+(?=€)`, the `pattern:€` sign doesn't get captured as a part of the match. That's natural: we look for a number `pattern:\d+`, while `pattern:(?=€)` is just a test that it should be followed by `subject:€`.
+যেমন এই প্যাটার্নে `pattern:\d+(?=€)`, `pattern:€` এই চিহ্নটি আমাদের মিলের অংশ হিসেবে দেখাবে না। এটিই স্বাভাবিক: কেননা আমরা এখানে একটি সংখ্যার `pattern:\d+` খুঁজ করছি, যেখানে `pattern:(?=€)` এটি দ্বারা শুধুমাত্র আমরা নিশ্চিত করছি সংখ্যাটি `subject:€` এরপর আসবে।
 
-But in some situations we might want to capture the lookaround expression as well, or a part of it. That's possible. Just wrap that part into additional parentheses.
+কিন্তু কিছু ক্ষেত্রে আমাদের লুক অ্যারাউন্ডের এক্সপ্রেশনটিকেও ক্যাপচার করতে হতে পারে, অথবা এর একটি অংশও হতে পারে। এটিও সম্ভব। আমাদের শুধু অংশটিকে আরেকটি আলাদা প্যারেন্টেসিসের মধ্যে লিখা লাগবে।
 
-In the example below the currency sign `pattern:(€|kr)` is captured, along with the amount:
+নিচের উদাহরণে আমরা দামের পাশাপাশি কারেন্সী চিহ্নকেও `pattern:(€|kr)` ক্যাপচার করব:
 
 ```js run
 let str = "1 turkey costs 30€";
-let regexp = /\d+(?=(€|kr))/; // extra parentheses around €|kr
+let regexp = /\d+(?=(€|kr))/; // অতিরিক্ত একটি প্যারেন্টেসিস €|kr
 
 alert( str.match(regexp) ); // 30, €
 ```
 
-And here's the same for lookbehind:
+লুকবিহাইন্ডের জন্য অনুরূপ:
 
 ```js run
 let str = "1 turkey costs $30";
@@ -110,21 +110,22 @@ let regexp = /(?<=(\$|£))\d+/;
 alert( str.match(regexp) ); // 30, $
 ```
 
-## Summary
+## সারাংশ
 
-Lookahead and lookbehind (commonly referred to as "lookaround") are useful when we'd like to match something depending on the context before/after it.
+"লুকঅ্যাহেড" এবং "লুকবিহাইন্ড" (একত্রে বলা হয়  "লুকঅ্যারাউন্ড") ব্যবহার উপযোগী যদি কোন অংশ এর আগে বা পরের অংশের উপর নির্ভর করে।
 
-For simple regexps we can do the similar thing manually. That is: match everything, in any context, and then filter by context in the loop.
+সাধারণ রেগুলার এক্সপ্রেশনের মাধ্যমেই আমরা একই ব্যাপার করতে পারি।
+অর্থাৎ যা সবকিছুর সাথেই মিল খুঁজবে, তারপর লুপের মাধ্যমে অই কন্টেক্সট গুলো যাচাই বাচাইয়ের মাধ্যমে খুঁজতে পারি।
 
-Remember, `str.match` (without flag `pattern:g`) and `str.matchAll` (always) return matches as arrays with `index` property, so we know where exactly in the text it is, and can check the context.
+মনে রাখবেন, `str.match` (`pattern:g` ফ্ল্যাগছাড়া) এবং `str.matchAll` (সর্বদাই) মিলগুলোকে `index` অ্যারে আকারে রিটার্ন করে, সুতরাং আমরা জানি আমাদের কোন ইনডেক্সে কোন কন্টেক্সট নিয়ে যাচাই বাছাই করা লাগবে।
 
-But generally lookaround is more convenient.
+তবে লুকঅ্যারাউন্ড এর মাধ্যমে আমরা এটি আরো সহজে করতে পারি।
 
-Lookaround types:
+লুকঅ্যারাউন্ড এর টাইপস:
 
-| Pattern            | type             | matches |
+| প্যাটার্ন            | টাইপ             | ম্যাচ |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Positive lookahead | `pattern:X` if followed by `pattern:Y` |
-| `X(?!Y)`   | Negative lookahead | `pattern:X` if not followed by `pattern:Y` |
-| `(?<=Y)X` |  Positive lookbehind | `pattern:X` if after `pattern:Y` |
-| `(?<!Y)X` | Negative lookbehind | `pattern:X` if not after `pattern:Y` |
+| `X(?=Y)`   | পজেটিভ লুকঅ্যাহেড | `pattern:X` এর পরবর্তী প্যাটার্ন হবে `pattern:Y` |
+| `X(?!Y)`   | নেগেটিভ লুকঅ্যাহেড | `pattern:X` এর পরবর্তী প্যাটার্ন `pattern:Y` হবে না |
+| `(?<=Y)X` |  পজেটিভ লুকবিহাইন্ড | `pattern:X` এর পূর্ববর্তী প্যাটার্ন হবে `pattern:Y` |
+| `(?<!Y)X` | নেগেটিভ লুকবিহাইন্ড | `pattern:X` এর পূর্ববর্তী প্যাটার্ন `pattern:Y` হবে না |
\ No newline at end of file

From 99cc197c92a9845b57599e654128e254ac58a377 Mon Sep 17 00:00:00 2001
From: Saiful <msisaifulsaif@gmail.com>
Date: Sun, 17 Jan 2021 16:48:11 +0600
Subject: [PATCH 2/3] Task 1

---
 .../1-find-non-negative-integers/solution.md         | 12 ++++++------
 .../1-find-non-negative-integers/task.md             | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
index a824409f9..bdd7589a9 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md
@@ -1,9 +1,9 @@
 
-The regexp for an integer number is `pattern:\d+`.
+পূর্ণসংখ্যার রেগুলার এক্সপ্রেশন হল `pattern:\d+`।
 
-We can exclude negatives by prepending it with the negative lookahead: `pattern:(?<!-)\d+`.
+আমরা ঋণাত্নক সংখ্যাগুলোকে বাদ দিতে পারি নেগেটিভ লুকবিহাইন্ড এর মাধ্যমে: `pattern:(?<!-)\d+`।
 
-Although, if we try it now, we may notice one more "extra" result:
+সম্ভবত, আমরা এটি চেষ্টা করতে পারি, তবে এক্ষেত্রে আমরা "অতিরিক্ত" ফলাফল পাব:
 
 ```js run
 let regexp = /(?<!-)\d+/g;
@@ -13,11 +13,11 @@ let str = "0 12 -5 123 -18";
 console.log( str.match(regexp) ); // 0, 12, 123, *!*8*/!*
 ```
 
-As you can see, it matches `match:8`, from `subject:-18`. To exclude it, we need to ensure that the regexp starts matching a number not from the middle of another (non-matching) number.
+এখানে দেখতে পাচ্ছি, `subject:-18` এর মিল `match:8`। এটিকে বাদ দিতে হলে, আমাদের নিশ্চিত হতে হবে রেগুলার এক্সপ্রেশনটি অন্য সংখ্যার মাঝে যাচাই করবে না।
 
-We can do it by specifying another negative lookbehind: `pattern:(?<!-)(?<!\d)\d+`. Now `pattern:(?<!\d)` ensures that a match does not start after another digit, just what we need.
+এজন্য আমরা আরো একটি লুকবিহাইন্ড ব্যবহার করতে পারি: `pattern:(?<!-)(?<!\d)\d+`। এখন `pattern:(?<!\d)` এর দ্বারা নিশ্চিত করছি কোন ম্যাচ অন্য ডিজিটের মাঝ থেকে যাচাই করবে না।
 
-We can also join them into a single lookbehind here:
+আমরা একে একটি লুকবিহাইন্ডে সংযোগ করতে পারি:
 
 ```js run
 let regexp = /(?<![-\d])\d+/g;
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
index cd58f9923..c9d0efa90 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/task.md
@@ -1,12 +1,12 @@
-# Find non-negative integers
+# অঋণাত্নক পূর্ণসংখ্যার অনুসন্ধান
 
-There's a string of integer numbers.
+এখানে পূর্ণসংখ্যার একটি স্ট্রিং আছে।
 
-Create a regexp that looks for only non-negative ones (zero is allowed).
+একটি রেগুলার এক্সপ্রেশন লিখুন যা অঋণাত্নক পূর্ণসংখ্যার অনুসন্ধান করে (শূন্যও অনুসন্ধান করবে)।
 
-An example of use:
+উদাহরণ:
 ```js
-let regexp = /your regexp/g;
+let regexp = /আপনার প্যাটার্ন/g;
 
 let str = "0 12 -5 123 -18";
 

From c4c0c00fd63e8040d775a9a541110e4a121e891b Mon Sep 17 00:00:00 2001
From: Saiful <msisaifulsaif@gmail.com>
Date: Sun, 17 Jan 2021 18:03:12 +0600
Subject: [PATCH 3/3] task 2

---
 .../2-insert-after-head/solution.md           | 23 ++++++++++++-------
 .../2-insert-after-head/task.md               | 12 +++++-----
 2 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
index 980a7fe66..a997c7b62 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/solution.md
@@ -1,9 +1,9 @@
+`<body>` ট্যাগ ভিতরে নতুন ট্যাগ স্থাপনের জন্য, আমাদের প্রথমে এটি খুঁজে বের করতে হবে। এজন্য আমরা এই রেগুলার এক্সপ্রেশনটি ব্যবহার করব `pattern:<body.*>`।
 
-Для того, чтобы вставить после тега `<body>`, нужно вначале его найти. Будем использовать регулярное выражение `pattern:<body.*>`.
+এই টাস্কের জন্য আমাদের `<body>` ট্যাগকে প্রতিস্থাপিত করা লাগবে না। আমাদের শুধুমাত্র ট্যাক্সটিকে সংযোগ করতে হবে।
 
-Далее, нам нужно оставить сам тег `<body>` на месте и добавить текст после него.
+এখানে দেখুন আমরা কিভাবে এটি করতে পারি:
 
-Это можно сделать вот так:
 ```js run
 let str = '...<body style="...">...';
 str = str.replace(/<body.*>/, '$&<h1>Hello</h1>');
@@ -11,9 +11,9 @@ str = str.replace(/<body.*>/, '$&<h1>Hello</h1>');
 alert(str); // ...<body style="..."><h1>Hello</h1>...
 ```
 
-В строке замены `$&` означает само совпадение, то есть мы заменяем `pattern:<body.*>` заменяется на самого себя плюс `<h1>Hello</h1>`.
+রিপ্লেসমেন্ট স্ট্রিংয়ে `$&` দ্বারা বুঝায় মিলের কন্টেন্টটি অর্থাৎ সোর্সের ট্যাক্সটি `pattern:<body.*>`। মিলকৃত কন্টেন্টটি অতঃপর `<h1>Hello</h1>`।
 
-Альтернативный вариант - использовать ретроспективную проверку:
+বিকল্প আরেকটি হতে পারে লুকবিহাইন্ড:
 
 ```js run
 let str = '...<body style="...">...';
@@ -22,8 +22,15 @@ str = str.replace(/(?<=<body.*>)/, `<h1>Hello</h1>`);
 alert(str); // ...<body style="..."><h1>Hello</h1>...
 ```
 
-Такое регулярное выражение на каждой позиции будет проверять, не идёт ли прямо перед ней `pattern:<body.*>`. Если да - совпадение найдено. Но сам тег `pattern:<body.*>` в совпадение не входит, он только участвует в проверке. А других символов после проверки в нём нет, так что текст совпадения будет пустым.
+এখানে দেখতে পাচ্ছি, এখানে রেগুলার এক্সপ্রেশনে শুধুমাত্র লুকবিহাইন্ডের অংশটি আছে।
 
-Происходит замена "пустой строки", перед которой идёт `pattern:<body.*>` на `<h1>Hello</h1>`. Что, как раз, и есть вставка этой строки после `<body>`.
+এটি এভাবে কাজ করছে:
+- টেক্সটের প্রতিটি পজিশনে।
+- যাচাই করছে পূর্বে `pattern:<body.*>` আছে কিনা।
+- যদি থাকে তাহলে আমাদের মিলটি পাব।
 
-P.S. Этому регулярному выражению не помешают флаги: `pattern:/<body.*>/si`, чтобы в "точку" входил перевод строки (тег может занимать несколько строк), а также чтобы теги в другом регистре типа `match:<BODY>` тоже находились.
+`pattern:<body.*>` ট্যাগটি রিটার্ন করবে না। সুতরাং রেজাল্ট হবে এম্পটি স্ট্রিং, কিন্ত ম্যাচটির অবস্থান হবে `pattern:<body.*>` এর পরের অবস্থানটি।
+
+সুতরা আমরা "empty line" টিকে রিপ্লেস করব  `<h1>Hello</h1>` দ্বারা যার পূর্বে `pattern:<body.*>` আছে। সুতরাং নতুন ট্যাগটি হবে `<body>` এর পর।
+
+লক্ষ্যনীয় রেগুলার এক্সপ্রেশন ফ্ল্যাগ, যেমন `pattern:s` এবং `pattern:i` দরকারী: `pattern:/<body.*>/si`। `pattern:s` ফ্ল্যাগটি `pattern:.` দ্বারা নিউলাইন ক্যারাক্টারকেও বুঝায়, এবং `pattern:i` ফ্ল্যাগ কেস-ইন্সেসিটিভ বুঝায় `pattern:<body>` এটি `match:<BODY>` এর সাথেও ম্যাচ করবে।
diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
index ac9e5e4ce..bf455cc4a 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/2-insert-after-head/task.md
@@ -1,13 +1,13 @@
-# Вставьте после фрагмента
+# Body এর ভিতরে H1 ট্যাগ
 
-Есть строка с HTML-документом.
+HTML Document এর একটি স্ট্রিং আছে।
 
-Вставьте после тега `<body>` (у него могут быть атрибуты) строку `<h1>Hello</h1>`.
+একটি রেগুলার এক্সপ্রেশন লিখুন যার মাধ্যমে `<body>` ট্যাগ এর পর `<h1>Hello</h1>` কে সংযোগ করতে পারি। ট্যাগটির একাধিক অ্যাট্রিবিউট থাকতে পারে।
 
-Например:
+উদাহরণস্বরূপ:
 
 ```js
-let regexp = /ваше регулярное выражение/;
+let regexp = /আপনার প্যাটার্ন/;
 
 let str = `
 <html>
@@ -20,7 +20,7 @@ let str = `
 str = str.replace(regexp, `<h1>Hello</h1>`);
 ```
 
-После этого значение `str`:
+এর পর `str` এর মান হবে:
 ```html
 <html>
   <body style="height: 200px"><h1>Hello</h1>