গ্লোব ম্যাচার কার্যকর করুন

Question

মিলে যাওয়ার জন্য প্যাটার্ন এবং স্ট্রিংয়ের কোনও ফাংশন প্রয়োগ করুন, প্যাটার্নটি পুরো স্ট্রিংয়ের সাথে মেলে যদি সত্য হয় ফিরে আসুন, অন্যথায় মিথ্যা।

আমাদের গ্লোব প্যাটার্ন সিনট্যাক্সটি হ'ল:

• ? যে কোনও একটি চরিত্রের সাথে মেলে
• + এক বা একাধিক অক্ষরের সাথে মেলে
• * শূন্য বা আরও বেশি অক্ষরের সাথে মেলে
• \ বেরিয়ে

নিয়মাবলী:

• কোনও ইভাল নয়, নিয়মিত অভিব্যক্তিতে রূপান্তরিত হবে না, কোনও সিস্টেম গ্লোব ফাংশন কল করছে না।
• আই / ও প্রয়োজন হয় না: আপনি কেবল একটি ফাংশন লিখতে পারেন
• সবচেয়ে কম জয়

উদাহরণ:

glob('abc', 'abc') => true
glob('abc', 'abcdef') => false IMPORTANT!
glob('a??', 'aww') => true
glob('a*b', 'ab') => true
glob('a*b', 'agwijgwbgioeb') => true
glob('a*?', 'a') => false
glob('?*', 'def') => true
glob('5+', '5ggggg') => true
glob('+', '') => false
glob('a\*b', 'a*b') => true

শুরু করার জন্য এখানে একটি পরামর্শ: http://en.wikedia.org/wiki/Backtracking

Comments

আমি কি একটি অতিরিক্ত ট্যাগ "প্যাটার্ন-ম্যাচিং" পরামর্শ দিতে পারি?

— dmckee --- প্রাক্তন-মডারেটর বিড়ালছানা

আপনি "কোনও স্ট্যান্ডার্ড ফাংশন" বলতে চাইছেন তা কি স্পষ্ট করে বলতে পারেন? আপনি স্ট্যান্ডার্ড লাইব্রেরি থেকে ফাংশন কল করতে পারবেন না? কীভাবে কাজ করার কথা?

— sepp2k

পালানোর কিছু উদাহরণ দয়া করে? ("\")

— ইয়েলভেক্স

Answer 1

গল্ফস্ক্রিপ্ট - 82 টি অক্ষর

{1,\@n+:|;{:<;{:I)I|="\\+*?"[<]+?[{|=<={I))}*}I~{I\C}{}.{;}]=~}:C%}/{|>'*'-n=},}:g

ধরে নিন যে স্ট্রিংগুলিতে কোনও নতুন লাইন নেই। মিথ্যার জন্য একটি ফাঁকা অ্যারে এবং সত্যের জন্য একটি খালি শূন্য অ্যারে (সত্য / মিথ্যাটির গল্ফস্ক্রিপ্ট সংজ্ঞা অনুসারে) প্রদান করে।

এটি একটি পুনরাবৃত্তিযোগ্য সমাধান (একটানা *গুলি ব্যতীত ), যা মেলে iএমন প্যাটার্ন স্ট্রিংয়ের পজিশনের একটি তালিকা বজায় রাখে ।pattern[0..i]string[0..cur]

এটি খুব দীর্ঘ সময় চালানোর সম্ভাবনা রয়েছে। এটি প্রতিরোধের জন্য আপনি .&পরে যুক্ত করতে পারেন :C%।

Answer 2

হাস্কেল, 141 টি অক্ষর

c('\\':a:z)s=a&s>>=c z
c(a:z)s=a%s>>=c z
c[]s=[null s]
p&(a:z)|a==p=[z]
_&_=[]
'?'%(a:z)=[z]
'*'%a=a:'+'%a
'+'%(a:z)='*'%z
l%a=l&a
g=(or.).c

সমস্ত ইনপুট, উভয় নিদর্শন এবং স্ট্রিংগুলির সাথে মেলে কাজ করে। আক্ষরিক মিল হিসাবে প্যাটার্নে পিছনে ব্যাকস্ল্যাশ পরিচালনা করে (আচরণটি অনির্দিষ্ট ছিল))

এটি নিম্নলিখিত পরীক্ষামূলক ড্রাইভারের সাথে চালানো যেতে পারে:

main = do
    globtest "abc" "abc"    True
    globtest "abc" "abcdef" False
    globtest "a??" "aww"    True
    globtest "a*b" "ab"     True
    globtest "a*b" "agwijgwbgioeb" True
    globtest "a*?" "a"      False
    globtest "?*" "def"     True
    globtest "5+" "5ggggg"  True
    globtest "+" ""         False
    globtest "a\\*b" "a*b"  True
  where
    globtest p s e =
      if g p s == e
        then putStrLn "pass"
        else putStrLn$"fail: g " ++ show p ++ " " ++ show s ++ " /= " ++ show e

---

আপডেট: আমি এই নির্দিষ্ট উত্তর সম্পর্কে একটি ব্লগ পোস্ট লিখেছিলাম , যেহেতু আমি মনে করি যে এটি খুব ভালভাবে দেখায় যে কীভাবে হাস্কেল এত সহজেই সমস্যাটি এনকোড করে ফেলেছে।

---

• সম্পাদনা করুন: (181 -> 174) প্রতিস্থাপন করা হয়েছে d এবং mঅপারেটরদের সাথে
• সম্পাদনা করুন: (174 -> 151) ইনলাইন করা r ইনc
• সম্পাদনা করুন: (151 -> 149) এর মধ্যে অপ্রয়োজনীয়ভাবে উত্পন্ন বিকল্পটি সরানো হয়েছে + ক্ষেত্রে
• সম্পাদনা করুন: (149 -> 141) এর %দ্বারা পরিচালিত একটি অপ্রয়োজনীয় ধারা সরিয়ে দিয়েছে&

Answer 3

পিএইচপি - 275 টি অক্ষর

<?function g($P,$I){$o='array_shift';if(@$I[0]==="")return 0;for(;$P;$o($P)){$p=$P[0];if($p=='?'|$p=='+'&&@$N===$o($I))return 0;if($p=='+'|$p=='*'&&$I&&g($P,array_slice($I,1)))return 1;if(!strpos(" ?+*\\",$p)&&$p!==$o($I))return 0;}return!$I;}

Ungolfed:

<?php

function g($P,$I) {
        if ($I && $I[0] === "") return false;
        for(;$P;array_shift($P)) {
                $p = $P[0];
                if( $p == '?' || $p == '+') {
                        if (NULL === array_shift($I)) {
                                return false;
                        }
                }
                if( $p=='+' || $p=='*' ) {
                        if ($I && g($P, array_slice($I,1))) {
                                return true;
                        }
                }
                if (!strpos(" ?+*\\",$p) && $p !== array_shift($I)) {
                        return false;
                }
        }
        return !$I;
}

function my_glob($pattern,$subject) {
    return !!g(str_split($pattern),str_split($subject));
}

Answer 4

অতিরিক্ত ভার্বোজ পাইথন ( 384 367 টি অক্ষর)

t=lambda a:a[1:] 
h=lambda a:a[0] 
n=lambda p,s:s and(h(p)==h(s)and m(t(p),t(s))) 
def m(p,s): 
 if not p: 
  return not s 
 else: 
  return { 
   '?':lambda p,s:s and m(t(p),t(s)), 
   '+':lambda p,s:s and(m(p,t(s))or m(t(p),t(s))), 
   '*':lambda p,s:m(t(p),s)or(s and m(p,t(s))), 
   '\\':lambda p,s:n(t(p),s), 
  }.get(h(p),n)(p,s) 
glob=lambda p,s:not not m(p,s)

এটি স্বল্পতম নয়, তবে এটি দুর্দান্ত এবং কার্যকরী। মাঝখানে প্রেরণ ডিক জিনিসটি সম্ভবত বিচ্ছিন্ন হয়ে যাওয়া হিসাবে পুনরায় লেখা যেতে পারে(h(p) == '?') and (? lambda body) টাইপ জিনিসের পারে। এইচ অপারেটরটি সংজ্ঞায়িত করা আমার কোনও লাভের জন্য কিছু অক্ষর ব্যয় করে, তবে মাথার জন্য একটি কীওয়ার্ড থাকা ভাল।

সময় অনুমতি পেলে পরে গল্ফস্ক্রিপ্ট করার জন্য আমি ক্র্যাক করতে চাই।

সম্পাদনা: ব্যবহারকারীর 300 এর রুবি উত্তর পড়ে '*' ক্ষেত্রে অপ্রয়োজনীয় তৃতীয় শাখা সরানো হয়েছে

Answer 5

সংক্ষিপ্ত স্নাপিয়ার পাইথন ২.6 (২ (২ টি অক্ষর)

golfed:

n=lambda p,s:p[0]==s[0]and m(p[1:],s[1:]) 
def m(p,s): 
 q,r,t,u=p[0],p[1:],s[0],s[1:] 
 return any((q=='?'and(t and m(r,u)),q=='+'and(t and(m(p,u)or m(r,u))),q=='*'and(m(r,s)or(t and m(p,u))),q=='\\'and n(r,s),q==t==0))or n(p,s) 
glob=lambda*a:m(*[list(x)+[0]for x in a])

ungolfed:

TERMINATOR = 0 

def unpack(a): 
    return a[0], a[1:] 

def terminated_string(s): 
    return list(s) + [TERMINATOR] 

def match_literal(p, s): 
    p_head, p_tail = unpack(p) 
    s_head, s_tail = unpack(s) 
    return p_head == s_head and match(p_tail, s_tail) 

def match(p, s): 
    p_head, p_tail = unpack(p) 
    s_head, s_tail = unpack(s) 
    return any(( 
        p_head == '?' and (s_head and match(p_tail, s_tail)), 
        p_head == '+' and (s_head and(match(p, s_tail) or match(p_tail, s_tail))), 
        p_head == '*' and (match(p_tail, s) or (s_head and match(p, s_tail))), 
        p_head == '\\' and match_literal(p_tail, s), 
        p_head == s_head == TERMINATOR, 
    )) or match_literal(p, s) 

def glob(p, s): 
    return match(terminated_string(p), terminated_string(s))

সমন্বিত:

• অলসভাবে মূল্যায়ন করা লজিকাল গন্ডগোল!
• সি স্টাইলের স্ট্রিং!
• একাধিক তুলনা বুদ্ধিমান!
• প্রচুর কুৎসিত!

খালি স্ট্রিং থেকে মাথাটা পপিংয়ের সময় যদি আপনি কোনও ধরণের টার্মিনেটর মান পেতে পারেন তবে কীভাবে জিনিসগুলি সরল করা হয়েছে তা চিত্রিত করার জন্য ব্যবহারকারীর 300 এর উত্তরে ক্রেডিট দিন।

আমি আশা করি মি এর যুক্তি ঘোষণার সময় মাথা / লেজ আনপ্যাকিং ইনলাইন সম্পাদন করা যেতে পারে। তারপরে এম ল্যাম্বডা হতে পারে, ঠিক যেমন তার বন্ধুরা এন এবং গ্লোব। পাইথন 2 এটি করতে পারে না এবং কিছুটা পড়ার পরে দেখে মনে হচ্ছে পাইথন 3ও পারে না। দুর্ভোগ।

পরীক্ষামূলক:

test_cases = { 
    ('abc', 'abc') : True, 
    ('abc', 'abcdef') : False, 
    ('a??', 'aww') : True, 
    ('a*b', 'ab') : True, 
    ('a*b', 'aqwghfkjdfgshkfsfddsobbob') : True, 
    ('a*?', 'a') : False, 
    ('?*', 'def') : True, 
    ('5+', '5ggggg') : True, 
    ('+', '') : False, 
}   
for (p, s) in test_cases: 
    computed_result = glob(p, s) 
    desired_result = test_cases[(p, s)] 
    print '%s %s' % (p, s) 
    print '\tPASS' if (computed_result == desired_result) else '\tFAIL' 

Answer 6

রুবি - 199 171

g=->p,s{x=(b=->a{a[1..-1]})[p];y=s[0];w=b[s];v=p[0];_=->p,s{p[0]==y&&g[x,w]}
v==??? g[x,y&&w||s]:v==?+? y&&g[?*+x,w]:v==?*?
y&&g[p,w]||g[x,s]:v==?\\? _[x,s]:v ? _[p,s]:!y}

Ungolfed:

def glob(pattern, subject)
        b=->a{a[1..-1]}
        _=->p,s{ p[0]==s[0] && glob(b[p],b[s]) }
        ({
                ??=>->p,s { glob(b[p], s[0] ? b[s] : s) },
                ?+=>->p,s { s[0] && glob(?*+b[p], b[s]) },
                ?*=>->p,s { s[0] && glob(p,b[s]) || glob(b[p],s) },
                ?\\=>->p,s{ _[b[p],s] },
                nil=>->p,s{ !subject[0] }
        }[pattern[0]] || _)[pattern, subject]
end

পরীক্ষা:

p glob('abc', 'abc')
p glob('abc', 'abcdef')
p glob('a??', 'aww')
p glob('a*b', 'ab')
p glob('a*b', 'agwijgwbgioeb')
p glob('a*?', 'a')
p glob('?*', 'def')
p glob('5+', '5ggggg')
p glob('+', '')

ছিনতাইয়ের উত্তরে অনুপ্রাণিত

Comments

আমি রুবি সম্পর্কে কিছুই জানি না, তবে আপনার কোড থেকে আমি শিখেছি যে সীমানা সূচকগুলি অ্যাক্সেস করা শূন্য করে। সুতরাং একটি খালি স্ট্রিং পপিং একটি শূন্য মান দেয় যা একটি স্ট্রিং টার্মিনেটর প্রতীক হিসাবে ব্যবহার করা যেতে পারে। সি-স্টাইল! ছিমছাম! আমি অনুমান করি যে প্রতিটি ইনপুট স্ট্রিংটি lambda s : list(s)+[None]

— পেরিয়ে অজগরটিতে

এর চেহারা থেকে, রুবি প্যাটার্ন ম্যাচিংয়ে তৈরি করেছেন। এটি অবশ্যই এই ধরণের সমস্যার জন্য কার্যকর।

— জনাথন এম ডেভিস

প্রকৃতপক্ষে ??আক্ষরিক =>অক্ষরগুলি হ'ল, রুবি হ্যাশগুলিতে কী / মান পৃথককারী এবং ->একটি ল্যাম্বডা শুরু করে :-) ( { ?? => ->{...} }কী "?"হিসাবে একটি হ্যাশ এবং মান হিসাবে ল্যাম্বদা রয়েছে )) তবে হ্যাঁ এর সাথে যেভাবে একসাথে ব্যবহৃত হয়েছে তা একক অক্ষরের সাথে প্যাটার্ন-মিলের মতো দেখায় :-)

— আরনাউড লে ব্ল্যাঙ্ক

Answer 7

সি ফাংশন - 178 প্রয়োজনীয় অক্ষর

জিসিসির সাথে সংকলিত, এটি কোনও সতর্কতা দেয় না।

#define g glob
int g(p,s)const char*p,*s;{return*p==42?g(p+1,s)||(*s&&g(p,
s+1)):*p==43?*s&&(g(p+1,++s)||g(p,s)):*p==63?*s&&g(p+1,s+1)
:*p==92?*++p&&*s++==*p++&&g(p,s):*s==*p++&&(!*s++||g(p,s));}
#undef g

প্রথম এবং শেষ লাইনগুলি অক্ষর গণনায় অন্তর্ভুক্ত নয়। এগুলি কেবল সুবিধার জন্য সরবরাহ করা হয়।

প্রস্ফুটিত:

int glob(p,s)
const char *p, *s; /* K&R-style function declaration */
{
    return
        *p=='*'  ? glob(p+1,s) || (*s && glob(p,s+1)) :
        *p=='+'  ? *s && (glob(p+1,++s) || glob(p,s)) :
        *p=='?'  ? *s && glob(p+1,s+1)                :
        *p=='\\' ? *++p && *s++==*p++ && glob(p,s)    :
        *s==*p++ && (!*s++ || glob(p,s));
}

Answer 8

জাভাস্ক্রিপ্ট - 259 টি অক্ষর

আমার বাস্তবায়ন খুব পুনরাবৃত্তিযোগ্য, সুতরাং যদি একটি দীর্ঘ দীর্ঘ প্যাটার্ন ব্যবহার করা হয় তবে স্ট্যাকটি উপচে পড়বে। প্লাস চিহ্নটি উপেক্ষা করা (যা আমি অনুকূলিত করতে পারি তবে সরলতার জন্য বেছে নিই নি), প্রতিটি টোকেনের জন্য একটি স্তর পুনরাবৃত্তি ব্যবহৃত হয়।

glob=function f(e,c){var b=e[0],d=e.slice(1),g=c.length;if(b=="+")return f("?*"+d,c);if(b=="?")b=g;else if(b=="*"){for(b=0;b<=g;++b)if(f(d,c.slice(b)))return 1;return 0}else{if(b=="\\"){b=e[1];d=e.slice(2)}b=b==c[0]}return b&&(!d.length&&!g||f(d,c.slice(1)))}

ফাংশনটি কখনও কখনও বুলেটিনের পরিবর্তে একটি নম্বর দেয়। যদি সমস্যা হয় তবে আপনি এটি হিসাবে ব্যবহার করতে পারেন !!glob(pattern, str)।

---

একটি দরকারী সংস্থান হিসাবে পরিবেশন করার জন্য দারোয়ান (অবিহীন, বরং):

function glob(pattern, str) {
    var head = pattern[0], tail = pattern.slice(1), strLen = str.length, matched;
    if(head == '+') {
        // The plus is really just syntactic sugar.
        return glob('?*' + tail, str);
    }
    if(head == '?') { // Match any single character
        matched = strLen;
    } else if(head == '*') { // Match zero or more characters.
        // N.B. I reuse the variable matched to save space.
        for(matched = 0; matched <= strLen; ++matched) {
            if(glob(tail, str.slice(matched))) {
                return 1;
            }
        }
        return 0;
    } else { // Match a literal character
        if(head == '\\') { // Handle escaping
            head = pattern[1];
            tail = pattern.slice(2);
        }
        matched = head == str[0];
    }
    return matched && ((!tail.length && !strLen) || glob(tail, str.slice(1)));
}

নোট করুন যে অ্যারের উপাদানগুলির জন্য স্ট্রিংয়ের অক্ষরগুলিতে ইনডেক্স করা পুরানো (ECMAScript 3) ভাষার মানের অংশ নয়, তাই এটি পুরানো ব্রাউজারগুলিতে কাজ নাও করতে পারে।

Answer 9

পাইথন (454 টি অক্ষর)

def glob(p,s):
  ps,pns=[0],[]
  for ch in s:
    for i in ps:
      if i<0:
        pns+=[i]
        if i>-len(p) and p[-i]==ch:pns+=[-i]
      elif i<len(p):
        pc=p[i]
        d={'?':[i+1],'+':[i,-i-1],'*':[i+1,-i-1]}
        if pc in d:pns+=d[pc]
        else:
          if pc=='\\':pc=p[i+1]
          if pc==ch:pns+=[i+1]
    ps,pns=pns,[]
  if (s or p in '*') and (len(p) in ps or -len(p)+1 in ps or -len(p) in ps): return True
  return False

Answer 10

ডি: 363 অক্ষর

bool glob(S)(S s,S t){alias front f;alias popFront p;alias empty e;while(!e(s)&&!e(t)){switch(f(s)){case'+':if(e(t))return false;p(t);case'*':p(s);if(e(s))return true;if(f(s)!='+'&&f(s)!='*'){for(;!e(t);p(t)){if(f(s)==f(t)&&glob(s,t))return true;}}break;case'\\':p(s);if(e(s))return false;default:if(f(s)!=f(s))return false;case'?':p(s);p(t);}}return e(s)&&e(t);}

আরও সুস্পষ্টভাবে:

bool glob(S)(S s, S t)
{
    alias front f;
    alias popFront p;
    alias empty e;

    while(!e(s) && !e(t))
    {
        switch(f(s))
        {
            case '+':
                if(e(t))
                    return false;

                p(t);
            case '*':
                p(s);

                if(e(s))
                    return true;

                if(f(s) != '+' && f(s) != '*')
                {
                    for(; !e(t); p(t))
                    {
                        if(f(s) == f(t) && glob(s, t))
                            return true;
                    }
                }

                break;
            case '\\':
                p(s);

                if(e(s))
                    return false;
            default:
                if(f(s) != f(s))
                    return false;
            case '?':
                p(s);
                p(t);
        }
    }

    return e(s) && e(t);
}

Answer 11

golfscript

{{;;}2$+}:x;{x if}:a;{x\if}:o;{1$1$}:b;{(@(@={\m}a}:r;{b(63={\({\m}a}a{b(43={\({\b m{'+'\+m}o}a}a{b(42={b m{\({\'*'\+m}a}o}a{b(92={r}a{b 0=0=\0=0=*{r}o}o}o}o}o}:m;{[0]+\[0]+m}:glob;

এটি স্ট্যাক, গুলি এবং পি থেকে দুটি আর্গুমেন্ট গ্রাস করে এবং একটি একক বুলিয়ান ফেরতের মান উত্পাদন করে এমন ফাংশনগুলি তৈরি করে। অলস এবং অলস বা অপারেটরগুলির সাথে সামঞ্জস্যপূর্ণ হওয়ার জন্য এখানে প্রায় কিছুটা হাসিখুশি রয়েছে। আমি সত্যিই সন্দেহ করি যে এই পদ্ধতিরটি সর্বোত্তম, বা এমনকি সঠিক দিকেও যে কোনও জায়গায়।

কয়েকটি বিনোদনের সাথে মূ .় মুহুর্তগুলিও রয়েছে, যেমন '*'প্যাটার্নটি বন্ধ করে দেওয়া, '*'তুলনা করে গ্রাস করা , কেবল বুঝতে যে পরবর্তী শাখাটি মেলে না। অন্য শাখায় নামার জন্য, আমাদের '*'সামনের অংশটির সাথে প্যাটার্নটি প্রয়োজন , তবে আমরা যখন পপ করলাম তখন আমরা সেই মূল প্যাটার্নটি গ্রাস করেছি '*'এবং আমরা গ্রাস করে ফেলেছি '*', তাই নিজেকে আবার প্যাটার্নটি পেতে আমরা একটি চকচকে নতুন স্ট্রিং লোড করি ধ্রুবক '*', এবং এটি জায়গায় প্রস্তুত। এটি আরও কৃপণ হয়ে ওঠে কারণ কোনও কারণে চরিত্রের মিলটি ascii মানগুলির সাথে করা প্রয়োজন, তবে স্ট্রিংটিতে ফিরে স্ট্রিংয়ের জন্য স্ট্রিংগুলির প্রয়োজন।

কম গল্ফ গল্ফস্ক্রিপ্ট

{[0]+}:terminate_string;
{{;;}2$+if}:_and;
{{;;}2$+\if}:_or;
{1$1$}:branch;
{(@(@={\match}_and}:match_literal;
{0=0=\0=0=*}:match_terminator;
{(92={match_literal}_and}:match_escape;
{(63={\({\match}_and}_and}:match_wildcard;
{(43={\({\branch match{'+'\+match}_or}_and}_and}:match_wildcard_plus;
{(42={branch match{\({\'*'\+match}_and}_or}_and}:match_wildcard_star;
{branch match_wildcard{branch match_wildcard_plus{branch match_wildcard_star{branch match_escape{branch match_terminator{match_literal}_or}_or}_or}_or}_or}:match;
{terminate_string\terminate_string match}:glob;

পরীক্ষা

{2$2$glob = "test passed: " "test FAILED: " if print \ print ' ; ' print print "\n" print}:test_case;

'abc' 'abc' 1 test_case
'abc' 'abcdef' 0 test_case
'a??' 'aww' 1 test_case
'a*b' 'ab' 1 test_case
'a*b' 'agwijgwbgioeb' 1 test_case
'a*?' 'a' 0 test_case
'?*' 'def' 1 test_case
'5+' '5ggggg' 1 test_case
'+' '' 0 test_case

Answer 12

সি # (251 টি অক্ষর)

static bool g(string p,string i){try{char c;System.Func<string,string>s=t=>t.Remove(0,1);return p==i||((c=p[0])==92?p[1]==i[0]&g(s(s(p)),s(i)):c==42?g(s(p),i)||g(p,s(i)):c==43?g(s(p),s(i))|g(p,s(i)):g(s(p),s(i))&(c==i[0]|c==63));}catch{return false;}}

সামান্য আরও পঠনযোগ্য:

static bool g(string p /* pattern */, string i /* input string */)
{
    // Instead of checking whether we’ve reached the end of the string, just
    // catch the out-of-range exception thrown by the string indexing operator
    try
    {
        char c;

        // .Remove(0,1) is shorter than .Substring(1)...
        System.Func<string, string> s = t => t.Remove(0, 1);

        // Note that every glob matches itself!† This saves us having to write
        // “(p=="" & i=="")” which would be much longer — very convenient!
        return p == i || (

            // backslash escapes
            (c = p[0]) == 92 ? p[1] == i[0] & g(s(s(p)), s(i)) :

            // '*' — need “||” so that s(i) doesn’t throw if the first part is true
            c == 42 ? g(s(p), i) || g(p, s(i)) :

            // '+'
            c == 43 ? g(s(p), s(i)) | g(p, s(i)) :

            // '?' or any other character
            g(s(p), s(i)) & (c == i[0] | c == 63)
        );
    }

    // If we ever access beyond the end of the string, we know the glob doesn’t match
    catch { return false; }
}

_{^† আমি জানি, আমি জানি ... ব্যাকস্ল্যাশযুক্ত গ্লোবগুলি বাদে। যা সত্যই দুর্ভাগ্যজনক। এটি অন্যথায় সত্যিই চালাক হত। :(}