พื้นหลัง

MQTT (Message Queuing Telemetry Transport) เป็นโปรโตคอลการรับส่งข้อความแบบบอกรับสมาชิกที่ใช้มาตรฐาน 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 / groundfloor / ครัว / ความสว่าง
✅โรงรถ / พื้น / ตู้เย็น / อุณหภูมิ / เพิ่มเติม / เฉพาะ / สาขา
❌ myhome / firstfloor / ห้องรับแขก / อุณหภูมิ
❌ myhome / ชั้นใต้ดิน / มุม / อุณหภูมิ

ข้อมูลเพิ่มเติมที่นี่

งาน

ใช้ฟังก์ชั่น / โปรแกรมที่ยอมรับสองสตริงและส่งคืนบูลีน สตริงแรกคือหัวข้อเรื่องที่สองคือหัวข้อเกณฑ์ หัวข้อเกณฑ์ใช้ไวยากรณ์การสมัครสมาชิกซึ่งมีรายละเอียดด้านบน ฟังก์ชั่นนี้เป็นจริงเมื่อวัตถุนั้นตรงกับเกณฑ์

กฎสำหรับงานนี้:

• หัวข้อคือ ASCII
• ไม่มีฟิลด์เงื่อนไขนอกเหนือจาก#สัญลักษณ์ตัวแทน
• สัญลักษณ์แทนไม่ปรากฏในหัวข้อเรื่อง
• จำนวนฟิลด์หัวเรื่อง> = จำนวนฟิลด์เกณฑ์
• ไม่มีฟิลด์ 0 อักขระหรือสแลชนำหน้าหรือต่อท้าย

กรณีทดสอบ

criteria1 = "myhome / groundfloor / + / temperature"
criteria2 = "+ / groundfloor / #"

("abc", "ab") => false
("abc", "abc") => true
("abc / de", "abc") => false
("myhome / groundfloor / ห้องรับแขก / อุณหภูมิ", criteria1 ) => จริง
("myhome / groundfloor / ครัว / อุณหภูมิ", criteria1) => จริง
("myhome / groundfloor / ห้องรับแขก / ความสว่าง", criteria1) => false
("myhome / firstfloor / ห้องรับแขก / อุณหภูมิ", criteria1) = > false
("โรงรถ / พื้น / ตู้เย็น / อุณหภูมิ", criteria1) => false
("myhome / groundfloor / ห้องรับแขก / อุณหภูมิ", criteria2) => จริง
("myhome / groundfloor / ครัว / ความสว่าง", criteria2) => true
("โรงรถ / ชั้นล่าง / ตู้เย็น / อุณหภูมิ / เพิ่มเติม / เฉพาะ / ฟิลด์ ", criteria2) => จริง
(" myhome / firstfloor / ห้องรับแขก / อุณหภูมิ ", criteria2) => false
("myhome / basement / corner / อุณหภูมิ", criteria2) => false
("music / kei $ ha / ล่าสุด", "+ / kei $ ha / +") => true

เยลลี่ 20 ไบต์

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

ลิงค์แบบ monadic ยอมรับรายการของตัวละคร[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?

Ruby , 65 ไบต์

โซลูชัน Regex ฉันเพิ่มRegex.escapeในกรณีที่ชื่อเกณฑ์เพียงเพื่อให้เป็นสิ่งที่ชอบcom.java/string[]/\nหรือสิ่งที่โง่ที่จะมีชิ้นส่วน regex

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

ลองออนไลน์!

โซลูชันที่ไม่ใช่ regex 77 ไบต์

ใช้เทคนิคการแบ่งซิปและการจับคู่ที่ดี ฉันพัฒนาอันนี้ก่อนที่จะตระหนักว่าแม้จะมีRegex.escapeวิธีการ regex จะสั้นลงอย่างไรก็ตาม

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

ลองออนไลน์!

Perl 5 -pl , 50 ไบต์

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

ลองออนไลน์!

Python 3 , 72 ไบต์

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

ลองออนไลน์!

ปัญหานี้สามารถทำให้การจับคู่ regex ง่ายขึ้นเล็กน้อย แต่วิธีการที่น่าสนใจอีกวิธีหนึ่งอาจให้ผลลัพธ์ที่ดีกว่า

แก้ไขฉันมากับวิธีแก้ปัญหา 107- ไบต์ไม่ใช้ regex ฉันไม่รู้ว่ามันจะสั้นกว่า 72 หรือบางทีฉันแค่ไม่เห็นวิธีการแก้ไขที่ถูกต้อง โครงสร้างการแบ่งซิปดูเหมือนจะใหญ่เกินไป ลองออนไลน์!

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ทุกคนพ่ายแพ้กับตัวอักษร regex

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 ไบต์

โดยไม่ต้องใช้ regex ด้วยความช่วยเหลือจาก Jonathan Allan และ Chas Brown

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 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เอา-ท์พุท (เอาท์พุทโดยนัยของ Charcoal true) สำหรับการแข่งขันไม่มีอะไรที่จะไม่ตรงกัน คำอธิบาย:

≔⪪Ｓ/θ

แยกเรื่องใน/s

≔⪪Ｓ/η

แยกเกณฑ์ใน/s

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

หากเกณฑ์มี (เช่นลงท้ายด้วย) a ให้#ลบออกและตัดแต่งหัวเรื่องตามความยาวใหม่ของเกณฑ์

Ｆ⌕Ａη+§≔θι+

ที่ไหนมีเกณฑ์ที่แล้วแทนที่องค์ประกอบว่าในเรื่องที่มี++

⁼θη

เปรียบเทียบหัวเรื่องกับเกณฑ์และพิมพ์ผลลัพธ์โดยปริยาย

เรติน่า 0.8.2 , 42 ไบต์

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

ลองออนไลน์! คำอธิบาย:

%`$
/

เติม a /ไปทั้งสองบรรทัด

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

ซ้ำแล้วซ้ำอีกเอาองค์ประกอบแรกของทั้งสองเรื่องและเกณฑ์ในขณะที่พวกเขาเท่ากับหรือองค์ประกอบเกณฑ์คือ +(ความสุข)

^¶$|¶#/$

เกณฑ์ตรงกับหากเป็นเพียงแค่#(ที่มีการ/เพิ่มก่อนหน้านี้) มิฉะนั้นทั้งหัวเรื่องและเกณฑ์ควรว่างเปล่าในจุดนี้

Pyth , 22 ไบต์

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

ลองออนไลน์!

เยลลี่ , 22 19 ไบต์

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

ลองออนไลน์!

ลิงก์ monadic ที่รับเป็นอาร์กิวเมนต์[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)