Greedy, Reluctant, এবং Possessive Quantifiers

Java রেগুলার এক্সপ্রেশন (Regex) প্যাটার্নে Greedy, Reluctant, এবং Possessive Quantifiers হলো এমন কনসেপ্ট যা স্ট্রিংয়ে মিলানোর সময় প্যাটার্নের খোঁজ কীভাবে হবে তা নিয়ন্ত্রণ করে। এই কনসেপ্টগুলি Quantifiers নামক অংশের অন্তর্গত, যা একটি প্যাটার্নের জন্য এক বা একাধিক ম্যাচ চিহ্নিত করার জন্য ব্যবহৃত হয়। সাধারণত, এগুলি স্ট্রিংয়ে কতটা মিল থাকবে তা নির্ধারণ করে।

১. Greedy Quantifiers:

Greedy Quantifiers একটি প্যাটার্নের জন্য যতটা সম্ভব মিল খোঁজার চেষ্টা করে। এটি "সবকিছু খাওয়ার" মতো কাজ করে, অর্থাৎ যতটুকু সম্ভব, পুরো প্যাটার্ন মেলানোর জন্য যতটা সম্ভব ক্যারেক্টার গ্রহণ করে।

Greedy Quantifiers-এর উদাহরণ:

• *: 0 বা তার বেশি
• +: 1 বা তার বেশি
• {n,m}: n থেকে m পর্যন্ত

উদাহরণ:

import java.util.regex.*;

public class GreedyQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("<.*>");
        Matcher matcher = pattern.matcher("<h1>Hello</h1> <h2>World</h2>");

        // find() মেথড ব্যবহার করে প্যাটার্ন খোঁজা
        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: <h1>Hello</h1> <h2>World</h2>

ব্যাখ্যা:

• .* একটি greedy quantifier যা যতটা সম্ভব মিল খোঁজার চেষ্টা করে। এখানে এটি <h1>Hello</h1> <h2>World</h2> পুরো অংশটিকে মিলিয়ে ফেলেছে। Greedy টাইপের কারণে এটি পুরো স্ট্রিংটির সাথে মিলছে, শুধুমাত্র প্রথম < থেকে শুরু হয়ে শেষ > পর্যন্ত।

২. Reluctant Quantifiers (Lazy Quantifiers):

Reluctant Quantifiers বা Lazy Quantifiers একটি প্যাটার্নের জন্য শুধুমাত্র যতটুকু সম্ভব মিল খোঁজার চেষ্টা করে। এটি একটি "কম খাওয়ার" মতো আচরণ করে, অর্থাৎ এটি প্রথম পাওয়ার পরেই মিল বন্ধ করে দেয়। এটি Greedy Quantifiers-এর বিপরীত।

Reluctant Quantifiers-এর উদাহরণ:

• *?: 0 বা তার বেশি (lazy)
• +?: 1 বা তার বেশি (lazy)
• {n,m}?: n থেকে m পর্যন্ত (lazy)

উদাহরণ:

import java.util.regex.*;

public class ReluctantQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("<.*?>");
        Matcher matcher = pattern.matcher("<h1>Hello</h1> <h2>World</h2>");

        // find() মেথড ব্যবহার করে প্যাটার্ন খোঁজা
        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: <h1>
Found match: </h1>
Found match: <h2>
Found match: </h2>

ব্যাখ্যা:

• .*? একটি reluctant quantifier যা যতটা সম্ভব কম মিল খোঁজার চেষ্টা করে। এখানে এটি শুধু < থেকে শুরু করে প্রথম > পর্যন্ত মিল পেয়েছে, তারপর আবার একই কাজ করেছে পরবর্তী অংশের জন্য।

৩. Possessive Quantifiers:

Possessive Quantifiers হল এমন একটি কনসেপ্ট যা Greedy Quantifiers-এর মতো কাজ করে, তবে এর মধ্যে একটি পার্থক্য রয়েছে: Possessive Quantifiers স্ট্রিংয়ের মধ্যে মিল পাওয়ার পর কিছুই পিছিয়ে ফিরে দেখতে চায় না। এটি কোনো backtracking করতে পারে না।

Possessive Quantifiers-এর উদাহরণ:

• *+: 0 বা তার বেশি (possessive)
• ++: 1 বা তার বেশি (possessive)
• {n,m}+: n থেকে m পর্যন্ত (possessive)

উদাহরণ:

import java.util.regex.*;

public class PossessiveQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("<.*+>");
        Matcher matcher = pattern.matcher("<h1>Hello</h1> <h2>World</h2>");

        // find() মেথড ব্যবহার করে প্যাটার্ন খোঁজা
        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: <h1>Hello</h1> <h2>World</h2>

ব্যাখ্যা:

• .*+ একটি possessive quantifier যা greedy quantifier এর মতো কাজ করে, তবে এটি ফিরে ফিরে দেখতে পারে না। এর মানে হলো এটি যতটুকু সম্ভব মিল খুঁজবে, কিন্তু একবার মিল পেলে কোন ব্যাকট্র্যাকিং করবে না।

Greedy, Reluctant, এবং Possessive Quantifiers-এর তুলনা:

সারাংশ:

1. Greedy Quantifiers: যতটা সম্ভব বেশি ক্যারেক্টার ম্যাচ করতে চেষ্টা করে।
2. Reluctant Quantifiers: যতটা সম্ভব কম ক্যারেক্টার ম্যাচ করতে চেষ্টা করে (কেবল প্রয়োজনীয় সংখ্যক ক্যারেক্টার মেলে)।
3. Possessive Quantifiers: Greedy এর মতো, তবে ব্যাকট্র্যাকিং ছাড়া (একবার ম্যাচ হলে আর পিছিয়ে ফিরে দেখে না)।

এগুলি আপনার রেগুলার এক্সপ্রেশন ম্যানিপুলেশন ও ম্যাচিংয়ের কৌশল নির্ধারণ করতে সাহায্য করে, এবং আপনার regex প্যাটার্নের মিল কতটা হওয়া উচিত তা নিয়ন্ত্রণ করে।

Java Regex (Regular Expressions)-এ Greedy Quantifiers হল এমন প্যাটার্ন, যা নির্দিষ্ট সংখ্যা বা শর্তের মধ্যে মিল খোঁজার জন্য ব্যবহৃত হয়। গ্রিডি কোয়ানটিফায়ারগুলি প্রাথমিকভাবে স্ট্রিংয়ের মধ্যে এমন সেগমেন্টের জন্য ব্যবহৃত হয়, যেগুলোর পরিমাণ সর্বাধিক হওয়ার চেষ্টা করে। এগুলি মূলত প্যাটার্নের সাথে মেলানোর সময় অধিক সংখ্যক অক্ষর নিয়ে মেলে, যতটা সম্ভব।

Greedy Quantifiers এর মধ্যে কিছু সাধারণ কোয়ানটিফায়ার রয়েছে: *, +, {n}, এবং {n,m}। এই কোয়ানটিফায়ারগুলি এমন ভাবে কাজ করে যাতে তারা যতটুকু সম্ভব ম্যাচ পেতে চেষ্টা করে, এবং এটাই তাদের "গ্রিডি" (greedy) আচরণ।

1. * (Asterisk) - 0 বা তার বেশি পুনরাবৃত্তি:

* কোয়ানটিফায়ারটি নির্দেশ করে যে, যেকোনো চরিত্র বা প্যাটার্ন শূন্য বা তার বেশি বার পুনরাবৃত্তি হতে পারে। অর্থাৎ, এটি zero বা more occurrences মেলে।

উদাহরণ:

import java.util.regex.*;

public class GreedyQuantifierAsteriskExample {
    public static void main(String[] args) {
        String text = "aaab aaaab";
        Pattern pattern = Pattern.compile("a*b");
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("Match found: " + matcher.group());
        }
    }
}

Output:

Match found: aaab
Match found: aaaab

ব্যাখ্যা:

• a*b প্যাটার্নটি b এর আগে যে কোনো সংখ্যা বা শূন্য a মেলে। এটি প্রথম aaab এবং দ্বিতীয় aaaab ম্যাচ করে, কারণ a* কোনো সংখ্যক a সহ মেলে।

2. + (Plus) - 1 বা তার বেশি পুনরাবৃত্তি:

+ কোয়ানটিফায়ারটি নির্দেশ করে যে, যেকোনো চরিত্র বা প্যাটার্ন একবার বা তার বেশি বার পুনরাবৃত্তি হতে পারে। অর্থাৎ, এটি one or more occurrences মেলে।

উদাহরণ:

import java.util.regex.*;

public class GreedyQuantifierPlusExample {
    public static void main(String[] args) {
        String text = "ab aaab aaaab";
        Pattern pattern = Pattern.compile("a+b");
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("Match found: " + matcher.group());
        }
    }
}

Output:

Match found: ab
Match found: aaab
Match found: aaaab

ব্যাখ্যা:

• a+b প্যাটার্নটি b এর আগে এক বা একাধিক a মেলে। ab, aaab, এবং aaaab সবই মেলে, কারণ এখানে এক বা তার বেশি a থাকতে হবে।

3. {n} (Exact n occurrences) - নির্দিষ্ট সংখ্যক পুনরাবৃত্তি:

{n} কোয়ানটিফায়ারটি নির্দেশ করে যে, একটি চরিত্র বা প্যাটার্ন ঠিক n বার পুনরাবৃত্তি হতে হবে। এটি একটি নির্দিষ্ট সংখ্যক বার পুনরাবৃত্তি খুঁজে।

উদাহরণ:

import java.util.regex.*;

public class GreedyQuantifierExactExample {
    public static void main(String[] args) {
        String text = "aab aaab aaaab";
        Pattern pattern = Pattern.compile("a{2}b");
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("Match found: " + matcher.group());
        }
    }
}

Output:

Match found: aab

ব্যাখ্যা:

• a{2}b প্যাটার্নটি এমন একটি স্ট্রিং খুঁজে যেখানে ঠিক দুইটি a এবং তারপরে একটি b রয়েছে। aab প্রথম স্ট্রিংটি মেলে, কিন্তু aaab এবং aaaab মেলে না, কারণ এখানে a এর সংখ্যা ২-এর বেশি।

4. {n,m} (Between n and m occurrences) - নির্দিষ্ট সীমার মধ্যে পুনরাবৃত্তি:

{n,m} কোয়ানটিফায়ারটি নির্দেশ করে যে, একটি চরিত্র বা প্যাটার্ন n থেকে m বার পুনরাবৃত্তি হতে পারে। এটি min to max occurrences মেলে।

উদাহরণ:

import java.util.regex.*;

public class GreedyQuantifierRangeExample {
    public static void main(String[] args) {
        String text = "aab aaab aaaab";
        Pattern pattern = Pattern.compile("a{2,3}b");
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("Match found: " + matcher.group());
        }
    }
}

Output:

Match found: aab
Match found: aaab

ব্যাখ্যা:

• a{2,3}b প্যাটার্নটি খুঁজে যেখানে a এর সংখ্যা ২ থেকে ৩ বার এবং তারপর একটি b থাকবে। এখানে aab এবং aaab মেলে, কিন্তু aaaab মেলে না, কারণ সেখানে a এর সংখ্যা ৩-এর বেশি।

Greedy Quantifiers এর চূড়ান্ত রিভিউ:

• Greedy Quantifiers হল Regex-এর শক্তিশালী উপাদান যা স্ট্রিংয়ের মধ্যে একাধিক ম্যাচ খুঁজে বের করতে সহায়তা করে।
• *, +, {n}, এবং {n,m} গ্রিডি কোয়ানটিফায়ারগুলি এমনভাবে কাজ করে যাতে তারা যতটুকু সম্ভব মেলানোর চেষ্টা করে, অর্থাৎ যতটুকু মিল পাওয়া যায়, ততটুকু ধরে রাখতে চেষ্টা করে।
• এই কোয়ানটিফায়ারগুলির ব্যবহার স্ট্রিংয়ের সঠিক অংশ খুঁজে বের করতে কার্যকরী এবং শক্তিশালী টুল হিসেবে কাজ করে।

Reluctant Quantifiers হল রেগুলার এক্সপ্রেশনে বিশেষ ধরনের কুয়ান্টিফায়ার, যা "লেজি" (lazy) ম্যাচিং কৌশল ব্যবহার করে। সাধারণত, কুয়ান্টিফায়ারগুলি "গ্রিপ" (greedy) হয়, অর্থাৎ তারা যতটা সম্ভব বেশি চরিত্র মিলাতে চায়। তবে, reluctant quantifiers কমপক্ষে একবার মেলে এবং যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করে। এগুলি lazy quantifiers হিসেবেও পরিচিত।

Reluctant Quantifiers:

1. *?: শূন্য বা একাধিক বার মিলাতে চেষ্টা করে, তবে যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করবে।
2. +?: এক বা একাধিক বার মিলাতে চেষ্টা করে, তবে যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করবে।
3. {n}?: ঠিক n বার মিলাতে চেষ্টা করে, তবে যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করবে।
4. {n,m}?: n থেকে m বার মিলাতে চেষ্টা করে, তবে যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করবে।

এগুলি সাধারণ কুয়ান্টিফায়ারের (যেমন, *, +, {n}, {n,m}) একই ধরনের, তবে এগুলি lazy (অথবা reluctant) হয়, অর্থাৎ, তারা চরিত্র গুলি কম ম্যাচ করার চেষ্টা করে।

1. *? (Reluctant Quantifier for 0 or more matches):

এটি "শূন্য বা একাধিক" মিলের জন্য ব্যবহৃত হয়, তবে যতটা সম্ভব কম চরিত্র মিলাতে চেষ্টা করে।

উদাহরণ:

import java.util.regex.*;

public class ReluctantQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("<.*?>");
        Matcher matcher = pattern.matcher("<html>Text</html>");
        
        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}

Output:

Found: <html>
Found: </html>

ব্যাখ্যা:

• <.*?>: এখানে *? যতটা সম্ভব কম চরিত্র মিলাতে চায়। এটি প্রথম < থেকে পরবর্তী > পর্যন্ত ছোট অংশ ম্যাচ করে এবং দ্বিতীয় <html> থেকে </html> পর্যন্ত ছোট অংশ ম্যাচ করে।
• .*? প্যাটার্নটি যতটা সম্ভব কম ম্যাচ করতে চেষ্টা করছে, তাই <html> এবং </html> দুটি আলাদা মেলানো অংশ হিসেবে বের হয়েছে।

2. +? (Reluctant Quantifier for 1 or more matches):

এটি "এক বা একাধিক" মিলের জন্য ব্যবহৃত হয়, তবে যতটা সম্ভব কম চরিত্র মিলাতে চেষ্টা করে।

উদাহরণ:

import java.util.regex.*;

public class ReluctantQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("<.+?>");
        Matcher matcher = pattern.matcher("<html>Text</html>");
        
        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}

Output:

Found: <html>
Found: </html>

ব্যাখ্যা:

• <.+?>: এখানে +? এক বা একাধিক চরিত্র মেলে, তবে যতটা সম্ভব কম চরিত্র মিলানোর চেষ্টা করে। এটি <html> এবং </html>-এর মধ্যে থাকা ছোট অংশ মিলিয়ে দেখাবে।

3. {n}? (Reluctant Quantifier for exactly n matches):

এটি নির্দিষ্ট সংখ্যক বার মিলানোর জন্য ব্যবহৃত হয়, তবে যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করে।

উদাহরণ:

import java.util.regex.*;

public class ReluctantQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d{2}?");
        Matcher matcher = pattern.matcher("12345");
        
        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}

Output:

Found: 12
Found: 34
Found: 45

ব্যাখ্যা:

• \\d{2}?: এখানে {2}? দুটি ডিজিট মেলে, কিন্তু যতটা সম্ভব কম ডিজিট ম্যাচ করতে চায়। এটি প্রথমে 12, তারপর 34, এবং শেষে 45 ম্যাচ করছে।

4. {n,m}? (Reluctant Quantifier for between n and m matches):

এটি n থেকে m বার মিলানোর জন্য ব্যবহৃত হয়, তবে যতটা সম্ভব কম চরিত্র ম্যাচ করার চেষ্টা করে।

উদাহরণ:

import java.util.regex.*;

public class ReluctantQuantifierExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d{2,4}?");
        Matcher matcher = pattern.matcher("123456");
        
        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}

Output:

Found: 12
Found: 34
Found: 56

ব্যাখ্যা:

• \\d{2,4}?: এখানে {2,4}? একটি সংখ্যা যেটি ২ থেকে ৪ বার মিলানোর চেষ্টা করে, তবে যতটা সম্ভব কম মিলাতে চায়। তাই এটি প্রথমে 12, তারপর 34, এবং শেষে 56 মেলে।

Reluctant Quantifiers এবং Greedy Quantifiers এর মধ্যে পার্থক্য:

• Greedy Quantifiers (যেমন *, +, {n,m}) যতটা সম্ভব বেশি মিলানোর চেষ্টা করে। উদাহরণস্বরূপ, .* যতটা সম্ভব বেশি চরিত্র মেলাতে চায়।
• Reluctant Quantifiers (যেমন *?, +?, {n,m}?) যতটা সম্ভব কম মিলানোর চেষ্টা করে। তারা শুধুমাত্র প্রথম সীমানায় মেলে এবং পরবর্তী মিলানোর জন্য অপেক্ষা করে।
• Reluctant Quantifiers রেগুলার এক্সপ্রেশন প্যাটার্নে গ্রিপি কুয়ান্টিফায়ারগুলির বিপরীতে কাজ করে, যা কম চরিত্র মিলানোর চেষ্টা করে। তারা বিশেষভাবে lazy matching করতে ব্যবহৃত হয়, যেখানে নির্দিষ্ট সীমানায় সবচেয়ে কম মিলানো হয়।
• এগুলি গুরুত্বপূর্ণ যখন আপনি স্ট্রিংয়ে নির্দিষ্ট অংশ খুঁজে পেতে চান, কিন্তু সেই অংশের মধ্যে অতিরিক্ত ক্যারেক্টার মিলানো থেকে এড়িয়ে যেতে চান।

Java Reflection Package মূলত ক্লাস, মেথড, ফিল্ড এবং কনস্ট্রাক্টরের তথ্যের উপর রিফ্লেকশন অপারেশন সম্পাদন করতে ব্যবহৃত হয়। তবে, আপনি যে বিষয়টি উল্লেখ করেছেন, তা Java Regular Expressions (Regex) এর অংশ। Possessive Quantifiers Regex-এর মধ্যে একটি গুরুত্বপূর্ণ কনসেপ্ট এবং এটি বিশেষভাবে স্ট্রিংয়ের কিছু নির্দিষ্ট সংখ্যক উপস্থিতি বা ম্যাচিং নির্ধারণ করতে ব্যবহৃত হয়।

এই পোস্টে Possessive Quantifiers যেমন *+, ++, {n}+, এবং {n,m}+ এর ব্যবহার আলোচনা করা হবে, যা রেগুলার এক্সপ্রেশন প্যাটার্নের মধ্যে ব্যবহৃত হয়। এগুলোর মাধ্যমে আপনি একটি প্যাটার্নের শর্তাবলী আরও নির্দিষ্টভাবে কাস্টমাইজ করতে পারেন।

1. *+ (Possessive Star Quantifier):

• *+ হল possessive quantifier, যা * এর মতো কাজ করে (যে কোন সংখ্যা, 0 বা তার বেশি), তবে এই quantifier ব্যবহার করলে এটি backtracking বন্ধ করে দেয়। অর্থাৎ, একবার এটি মিলানো শুরু করলে এটি আর ফিরে যাবে না।

Syntax:

x*+

• এখানে x এর 0 বা তার বেশি উপস্থিতি মেলা হবে, কিন্তু backtracking হবে না।

Example:

import java.util.regex.*;

public class PossessiveStarExample {
    public static void main(String[] args) {
        String regex = "a*+b"; // Possessive star quantifier
        String text = "aaab";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        
        // Testing for match
        boolean isMatch = matcher.matches();
        System.out.println("Does it match? " + isMatch); // true
    }
}

Output:

Does it match? true

ব্যাখ্যা:

• এখানে a*+ প্যাটার্নটি a এর 0 বা তার বেশি উপস্থিতি মেলায়, তবে possessive nature এর কারণে এটি একটি বারেই মেলাতে থাকে এবং ফিরে যায় না, যতক্ষণ না এটি পুরো স্ট্রিং মেলে।

2. ++ (Possessive Plus Quantifier):

• ++ হল possessive quantifier যা + এর মতো কাজ করে (অর্থাৎ, একটি বা তার বেশি), তবে এটি backtracking বন্ধ করে দেয়। একবার এটি মিলানো শুরু করলে এটি আর ফিরে যাবে না।

Syntax:

x++ 

• এখানে x এর এক বা তার বেশি উপস্থিতি মেলা হবে, কিন্তু backtracking হবে না।

Example:

import java.util.regex.*;

public class PossessivePlusExample {
    public static void main(String[] args) {
        String regex = "a++b"; // Possessive plus quantifier
        String text = "aaab";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        
        // Testing for match
        boolean isMatch = matcher.matches();
        System.out.println("Does it match? " + isMatch); // true
    }
}

Output:

Does it match? true

ব্যাখ্যা:

• a++ প্যাটার্নটি a এর এক বা তার বেশি উপস্থিতি মেলায়, তবে possessive nature এর কারণে এটি একবারে ম্যাচ করে, ফিরিয়ে যায় না।

3. {n}+ (Possessive Quantifier with Fixed Number):

• {n}+ হল possessive quantifier যা {n} (exactly n occurrences) এর মতো কাজ করে, তবে এটি backtracking বন্ধ করে দেয়। একবার এটি n সংখ্যক উপস্থিতি মিলালে, এটি আর পিছনে ফিরে যাবে না।

Syntax:

x{n}+

• এখানে x এর ঠিক n বার উপস্থিতি মেলা হবে, তবে backtracking হবে না।

Example:

import java.util.regex.*;

public class PossessiveNExample {
    public static void main(String[] args) {
        String regex = "a{3}+"; // Possessive quantifier with exactly 3 occurrences
        String text = "aaa";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        
        // Testing for match
        boolean isMatch = matcher.matches();
        System.out.println("Does it match? " + isMatch); // true
    }
}

Output:

Does it match? true

ব্যাখ্যা:

• a{3}+ প্যাটার্নটি ঠিক 3টি a খুঁজে এবং একবারে মেলে, তবে এটি possessive nature এর কারণে আর backtrack করবে না।

4. {n,m}+ (Possessive Quantifier with Range):

• {n,m}+ হল possessive quantifier যা {n,m} (between n and m occurrences) এর মতো কাজ করে, তবে এটি backtracking বন্ধ করে দেয়। একবার এটি n থেকে m সংখ্যক উপস্থিতি মিলালে, এটি আর ফিরে যাবে না।

Syntax:

x{n,m}+

• এখানে x এর n থেকে m বার উপস্থিতি মেলা হবে, তবে backtracking হবে না।

Example:

import java.util.regex.*;

public class PossessiveRangeExample {
    public static void main(String[] args) {
        String regex = "a{2,4}+"; // Possessive quantifier with range 2 to 4 occurrences
        String text = "aaab";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        
        // Testing for match
        boolean isMatch = matcher.matches();
        System.out.println("Does it match? " + isMatch); // true
    }
}

Output:

Does it match? true

ব্যাখ্যা:

• a{2,4}+ প্যাটার্নটি a এর 2 থেকে 4 বার উপস্থিতি খুঁজে, তবে possessive nature এর কারণে একবারেই মিলানো হয় এবং আর পিছনে ফিরে যাবে না।

• Possessive Quantifiers (*+, ++, {n}+, {n,m}+) হল এমন রেগুলার এক্সপ্রেশন quantifiers যা backtracking বন্ধ করে দেয় এবং এটি দ্রুত ম্যাচিং সুনিশ্চিত করে।
• এগুলি সাধারণ *, +, এবং {n,m} এর মতোই কাজ করে, তবে এই quantifiers ব্যবহার করলে এটি backtracking বন্ধ করে দেয়, যা অধিকাংশ ক্ষেত্রে স্ট্রিং ম্যাচিং দ্রুত সম্পন্ন করে।

এগুলি ব্যবহার করে আপনি আপনার রেগুলার এক্সপ্রেশন প্যাটার্নগুলো আরও দ্রুত এবং দক্ষভাবে তৈরি করতে পারেন, যেখানে backtracking এর প্রয়োজন হয় না।

Java Regular Expressions (Regex)-এ Quantifiers একটি গুরুত্বপূর্ণ ভূমিকা পালন করে, যেগুলি প্যাটার্নের মধ্যে একটি ক্যারেক্টারের সংখ্যা নিয়ন্ত্রণ করতে ব্যবহৃত হয়। Quantifiers নির্দিষ্ট করে কতবার একটি নির্দিষ্ট ক্যারেক্টার বা সাব-প্যাটার্ন মেলাতে হবে। Java Regex-এর Pattern এবং Matcher ক্লাসের মাধ্যমে এগুলি ব্যবহৃত হয়, যেগুলি রেগুলার এক্সপ্রেশন ব্যবহারে ব্যাপকভাবে সহায়ক।

Quantifiers in Java Regex

Quantifiers-গুলি রেগুলার এক্সপ্রেশনের গুরুত্বপূর্ণ অংশ, যা স্ট্রিংয়ের মধ্যে সুনির্দিষ্ট প্যাটার্নের মেলানো সংখ্যার সীমা নির্ধারণ করে। Java Regex-এর মধ্যে কিছু সাধারণ Quantifiers হল:

1. * (Zero or more)
   • এটি বলে যে, আগের ক্যারেক্টার বা সাব-প্যাটার্নটি শূন্য বা একাধিক বার আসতে পারে।
   • Example: a* — এখানে a শূন্য বা একাধিক বার আসতে পারে।
2. + (One or more)
   • এটি বলে যে, আগের ক্যারেক্টার বা সাব-প্যাটার্নটি এক বা একাধিক বার আসতে হবে।
   • Example: a+ — এখানে a এক বা একাধিক বার আসতে হবে।
3. ? (Zero or one)
   • এটি বলে যে, আগের ক্যারেক্টার বা সাব-প্যাটার্নটি শূন্য বা এক বার আসতে হবে।
   • Example: a? — এখানে a শূন্য বা একবার আসতে পারে।
4. {n} (Exact number of occurrences)
   • এটি বলে যে, আগের ক্যারেক্টার বা সাব-প্যাটার্নটি ঠিক n বার আসতে হবে।
   • Example: a{3} — এখানে a ঠিক ৩ বার আসতে হবে (যেমন "aaa")।
5. {n,} (At least n occurrences)
   • এটি বলে যে, আগের ক্যারেক্টার বা সাব-প্যাটার্নটি অন্তত n বার আসতে হবে।
   • Example: a{2,} — এখানে a কমপক্ষে ২ বার আসতে হবে (যেমন "aa", "aaa", "aaaa" ইত্যাদি)।
6. {n,m} (Between n and m occurrences)
   • এটি বলে যে, আগের ক্যারেক্টার বা সাব-প্যাটার্নটি n থেকে m বার আসতে পারে।
   • Example: a{2,4} — এখানে a ২ থেকে ৪ বার আসতে হবে (যেমন "aa", "aaa", "aaaa")।

Quantifiers: Practical Examples in Java

এখন আমরা Quantifiers এর কিছু ব্যবহারিক উদাহরণ দেখব। এসব উদাহরণ Java Pattern এবং Matcher ক্লাসের মাধ্যমে বাস্তবায়িত করা হবে।

1. Zero or More Quantifier (*):

import java.util.regex.*;

public class QuantifierExample {
    public static void main(String[] args) {
        String input = "aaa aa a";
        
        // Patter for zero or more 'a' characters
        Pattern pattern = Pattern.compile("a*");
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: aaa
Found match:  
Found match: aa
Found match:  
Found match: a

ব্যাখ্যা:

• a*: এখানে এটি বলছে যে a শূন্য বা একাধিক বার উপস্থিত হতে পারে, তাই এটি খালি স্ট্রিংও ম্যাচ করে, এবং একাধিক "a" সিকোয়েন্সও ম্যাচ করে।

2. One or More Quantifier (+):

import java.util.regex.*;

public class QuantifierExample {
    public static void main(String[] args) {
        String input = "aaa aa a";
        
        // Pattern for one or more 'a' characters
        Pattern pattern = Pattern.compile("a+");
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: aaa
Found match: aa
Found match: a

ব্যাখ্যা:

• a+: এটি বলছে যে a এক বা একাধিক বার থাকতে হবে, তাই এটি শুধু সেই অংশগুলি ম্যাচ করবে যেখানে কমপক্ষে একটি a রয়েছে।

3. Exact Number of Occurrences ({n}):

import java.util.regex.*;

public class QuantifierExample {
    public static void main(String[] args) {
        String input = "aaaa aaa aa a";
        
        // Pattern for exactly 3 'a' characters
        Pattern pattern = Pattern.compile("a{3}");
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: aaa

ব্যাখ্যা:

• a{3}: এটি বলছে যে a অবশ্যই ৩ বার আসতে হবে, তাই শুধুমাত্র "aaa" অংশটি ম্যাচ হবে।

4. Between n and m Occurrences ({n,m}):

import java.util.regex.*;

public class QuantifierExample {
    public static void main(String[] args) {
        String input = "aaaa aaa aa a";
        
        // Pattern for between 2 and 4 'a' characters
        Pattern pattern = Pattern.compile("a{2,4}");
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

Output:

Found match: aaaa
Found match: aaa
Found match: aa

ব্যাখ্যা:

• a{2,4}: এটি বলছে যে a ২ থেকে ৪ বার থাকতে হবে, তাই "aaaa", "aaa", এবং "aa" অংশগুলি ম্যাচ করবে।

Performance Impact of Quantifiers:

Quantifiers ব্যবহারের সাথে performance সম্পর্কিত কিছু বিষয় থাকতে পারে, বিশেষত greedy quantifiers (*, +) এর ক্ষেত্রে। এগুলি স্ট্রিংয়ের সমস্ত অংশ স্ক্যান করতে পারে, যার ফলে পারফরম্যান্সের উপর প্রভাব পড়তে পারে। নিচে কিছু বিষয় আলোচনা করা হলো:

1. Greedy vs Lazy Matching:
   • Greedy quantifiers যেমন * এবং +, যতটা সম্ভব বেশি ম্যাচ করার চেষ্টা করে। এটি বৃহৎ ইনপুট স্ট্রিংয়ের জন্য পারফরম্যান্সে প্রভাব ফেলতে পারে। উদাহরণস্বরূপ, একটি স্ট্রিংয়ে কয়েক হাজার a এবং b এর সংমিশ্রণ থাকলে a* প্যাটার্ন একটি বড় অংশ ম্যাচ করতে পারে।
2. Backtracking:
   • যদি একটি প্যাটার্ন খুবই কম্প্লেক্স হয় বা অনেক সম্ভাব্য ম্যাচ থাকে, তখন regex একাধিক ব্যাকট্র্যাকিং করবে (অর্থাৎ, সম্ভাব্য অন্যান্য সমাধান চেক করবে)। এটি কার্যকরভাবে স্ট্রিংয়ের বিভিন্ন অংশ পরীক্ষা করে এবং এটা পারফরম্যান্সের জন্য খুবই খারাপ হতে পারে।
3. Efficient Quantifier Usage:
   • Lazy quantifiers যেমন *? এবং +? (যেগুলি কম ম্যাচ করার চেষ্টা করে), ব্যাকট্র্যাকিং কম করে এবং সাধারণত ভালো পারফরম্যান্স দেয়। এটি বিশেষ করে ব্যবহার করা উচিত যখন স্ট্রিংয়ের অনেকাংশে মিল না থাকে।
4. Limited Matches:
   • {n,m} ব্যবহার করে আপনি মেলানোর সংখ্যা সীমিত করতে পারেন। এটি অযথা ব্যাকট্র্যাকিং কমাতে সাহায্য করবে এবং পারফরম্যান্সে উন্নতি আনতে পারে।

• Quantifiers (*, +, {n,m}) Java Regex-এর অন্যতম গুরুত্বপূর্ণ অংশ, যা স্ট্রিংয়ের মধ্যে সুনির্দিষ্ট সংখ্যা পর্যন্ত মেলানো বা সীমাবদ্ধতা প্রয়োগ করতে ব্যবহৃত হয়।
• Greedy quantifiers বড় ইনপুটের ক্ষেত্রে পারফরম্যান্সের উপর প্রভাব ফেলতে পারে, বিশেষ করে যখন স্ট্রিংয়ে অনেক মিল থাকে।
• Lazy quantifiers এবং limited matching টেকনিক ব্যবহার করলে পারফরম্যান্স উন্নত করা সম্ভব।