背景

MQTT（消息队列遥测传输）是一种基于ISO标准基于发布-订阅的消息传递协议（Wikipedia）。

每条消息都有一个主题，例如以下示例：

• myhome/groundfloor/livingroom/temperature
• USA/California/San Francisco/Silicon Valley
• 5ff4a2ce-e485-40f4-826c-b1a5d81be9b6/status
• Germany/Bavaria/car/2382340923453/latitude

MQTT客户端可以使用通配符订阅消息主题：

• 单层： +
• 所有级别开始： #

例如，订阅myhome/groundfloor/+/temperature将产生以下结果（不符合项以粗体显示）：

✅myhome /地面/客厅/温度
✅myhome /地面/厨房/温度 ❌myhome / 地面 /客厅/温度
/ 亮度
❌myhome / 第一层 /客厅/温度
❌ 车库 /地面/ 冰箱 /温度

订阅+/groundfloor/#将产生以下结果：

✅myhome /地面/客厅/温度
✅myhome /地面/厨房/亮度
✅车库/地面/冰箱/温度/更多/特定的/领域
/ myhome / 第一层 /客厅/温度
❌myhome / 地下室 /角/温度

更多信息在这里。

任务

实现一个接受两个字符串并返回布尔值的函数/程序。第一个字符串是主题主题，第二个是标准主题。条件主题使用上面详细介绍的订阅语法。当受试者符合标准时，该功能是正确的。

此任务的规则：

• 主题是ASCII
• #通配符之外没有标准字段
• 通配符不会出现在主题中
• 主题字段数> =条件字段数
• 没有0个字符的字段，也没有正斜杠的开头或结尾

测试用例

条件1 =“ myhome / groundfloor / + / temperature”
标准2 =“ + / groundfloor /＃”

（“ abc”，“ ab”）=>否
（“ abc”，“ abc”）=>正确
（“ abc / de”，“ abc”）=>
否（“ myhome / groundfloor / livingroom / temperature”，条件1 ）=> true
（“ myhome / groundfloor / kitchen / temperature”，criteria1）=> true
（“ myhome / groundfloor / livingroom / brightness”，criteria1）=> false
（“ myhome / firstfloor / livingroom / temperature”，条件1）= > false
（“车库/地面/冰箱/温度”，criteria1）=> false
（“ myhome /地面/客厅/客厅/温度”，criteria2）=> true
（“ myhome /地面/厨房/厨房/亮度”，criteria2）=> true
（“车库/地面/冰箱/温度/更多/特定/领域”，criteria2）=> true
（“ myhome /一楼/客厅/温度/温度”，criteria2）=> false
（“ myhome /地下室/角落/温度”，criteria2）=>否
（“音乐/ kei $ ha /最新”，“ + / kei $ ha / +”）=> true

果冻，20字节

ṣ€”/ZṖF”#eƊ¿œiÐḟ”+ZE

接受字符列表的单子链接[topic, pattern]，分别返回1或0匹配或不匹配。

在线尝试！或见一个测试套件。

怎么样？

ṣ€”/ZṖF”#eƊ¿œiÐḟ”+ZE - Link: list of lists of characters, [topic, pattern]
 €                   - for each:
ṣ                    -   split at occurrences of:
  ”/                 -     '/' character
    Z                - transpose (any excess of topic is kept)
           ¿         - while...
          Ɗ          - ...condition: last three links as a monad:
       ”#            -   '#' character
         e           -   exists in:
      F              -     flatten
     Ṗ               - ...do: pop the tail off
              Ðḟ     - filter discard those for which:
            œi       -   first multi-dimensional index of: ([] if not found, which is falsey)
                ”+   -     '+' character
                  Z  - transpose
                   E - all equal?

红宝石，65字节

正则表达式解决方案。我添加Regex.escape了一个标准名称，以防它恰好是类似com.java/string[]/\n正则表达式的东西或愚蠢的东西。

->s,c{s=~/^#{Regexp.escape(c).sub('\#','.*').gsub'\+','[^/]*'}$/}

在线尝试！

非正则表达式解决方案，77字节

使用一种很好的简单拆分，压缩和匹配技术。我首先开发了此程序，然后才意识到即使使用Regex.escaperegex解决方案，它总会变得更短。

->s,c{s.split(?/).zip(c.split ?/).all?{|i,j|i==j||'+#'[j||9]||!j&&c[-1]==?#}}

在线尝试！

Perl 5，50 -pl个字节

$_="\Q$_";s|\\\+|[^/]+|g;s/\\\#/.*/;$_=<>=~m|^$_$|

在线尝试！

Python 3，72个字节

lambda a,b:bool(re.match(b.translate({43:"[^/]+",35:".+"}),a))
import re

在线尝试！

这个问题可以简单地简化为正则表达式匹配，尽管另一种更有趣的方法可能会产生更好的结果。

编辑我想出了一个不使用正则表达式的107字节解决方案。我不知道它是否可以小于72，或者我只是没有看到正确的方法。但是，仅split-zip结构似乎太大。在线尝试！

Python 2中，85个 84 80 92 89字节

lambda s,c:all(x in('+','#',y)for x,y in zip(c.split('/')+[0]*-c.find('#'),s.split('/')))

在线尝试！

感谢Jonathan Allan和Value Ink指出错误。

Haskell，76 73 71 67字节

(a:b)#(c:d)=a=='+'&&b#snd(span(/='/')d)||a=='#'||a==c&&b#d
a#b=a==b

在线尝试！

编辑：-4字节感谢@cole。

Clojure，107 91 76 65 102字节

一个匿名函数，返回主题主题为真和nil假（在Clojure中有效）。

(defn ?[t c](every? #(#{"#""+"(% 0)}(% 1))(apply #(map vector % %2)(map #(re-seq #"[^/]+" %) [t c]))))

107 102工作
91 76 65所有与败字符正则表达式

Kotlin，106字节

fun f(s:List<String>)=s[1].split("/").filterIndexed{i,v->v!="+"&&v!="#"&&v!=s[0].split("/")[i]}.count()==0

在线尝试！

Python 3，99 88字节

不使用正则表达式。在乔纳森·艾伦和查斯·布朗的协助下。

f=lambda s,p:p in(s,'#')or p[:1]in(s[:1],'+')and f(s[1:],p['+'!=p[:1]or(s[:1]in'/')*2:])

木炭，36字节

≔⪪Ｓ/θ≔⪪Ｓ/ηＦ∧№η#⊟η≔…θＬηθＦ⌕Ａη+§≔θι+⁼θη

在线尝试！链接是详细版本的代码。匹配的输出-（炭笔的隐式输出true），没有匹配则为零。说明：

≔⪪Ｓ/θ

在上分割主题/。

≔⪪Ｓ/η

在/s 上拆分条件。

Ｆ∧№η#⊟η≔…θＬηθ

如果条件包含（即以）结尾，#则将其删除并将主题修剪为新的条件长度。

Ｆ⌕Ａη+§≔θι+

如果条件包含+，则将主题中的该元素替换为+。

⁼θη

将主题与条件进行比较，然后隐式打印结果。

视网膜0.8.2，42字节

%`$
/
+`^([^/]+/)(.*¶)(\1|\+/)
$2
^¶$|¶#/$

在线尝试！说明：

%`$
/

/两行都加后缀a 。

+`^([^/]+/)(.*¶)(\1|\+/)
$2

重复删除主题和条件相等的第一个元素，或者条件元素为（happy）+。

^¶$|¶#/$

如果条件仅仅是#（与/之前添加的）条件，则条件匹配，否则，此时主题和条件都应为空。

Pyth，22个字节

:Q::E"[+]""[^/]+"\#".*

在线尝试！

果冻，22 19字节

ḟ”+ṣ”/)ZẠƇṖœi”#$¿ZE

在线尝试！

以参数作为单子链接[topic], [criterion]并返回1匹配结果和0不匹配结果的链接。

JavaScript，69 66字节

t=>s=>new RegExp(s.split`+`.join`[^/]+`.split`#`.join`.+`).test(t)

在线尝试！

Python 3中，149个 148字节的

def f(t,c):t,c=t.split('/'),c.split('/');return all([c[i]=='+'or c[i]==t[i]or c[i]=='#'for i in range(len(c))])and not(len(c)!=len(t)and c[-1]!='#')

在线尝试！

05AB1E，21 字节

ε'/¡}ζʒ'+å≠}˜'#¡н2ôøË

按顺序输入清单[criteria, topic]。

在线尝试或验证所有测试用例。

说明：

ε                      # Map both strings in the implicit input-list to:
 '/¡                  '#  Split the string on "/"
                       #   i.e. ["+/+/A/B/#","z/y/A/B/x/w/v/u"]
                       #    → [["+","+","A","B","#"],["z","y","A","B","x","w","v","u"]]
    }ζ                 # After the map: zip/transpose the two string-lists,
                       # with space as (default) filler
                       #  → [["+","z"],["+","y"],["A","A"],["B","B"],["#","x"],[" ","w"],
                       #     [" ","v"],[" ","u"]]
      ʒ    }           # Filter each pair by:
       '+å≠           '#  Only keep those which do NOT contain a "+"
                       #   → [["A","A"],["B","B"],["#","x"],[" ","w"],[" ","v"],[" ","u"]]
            ˜          # Flatten the filtered list
                       #  → ["A","A","B","B","#","x"," ","w"," ","v"," ","u"]
             '#¡      '# Split the list by "#"
                       #  → [["A","A","B","B"],["x"," ","w"," ","v"," ","u"]]
                н      # Only keep the first part
                       #  → ["A","A","B","B"]
                 2ô    # Split this back into pairs of two
                       #  → [["A","A"],["B","B"]]
                   ø   # Zip/transpose them back
                       #  → [["A","B"],["A","B"]]
                    Ë  # And check if both inner lists are equal
                       #  → 1 (truthy)
                       # (after which the result is output implicitly)