งานนี้คือการส่งออกเส้นทางที่สั้นที่สุดไปยังไฟล์หลังจากการขยาย glob

เปลือกกลมคืออะไร? ในเชลล์ส่วนใหญ่คุณสามารถใช้*อักขระในพา ธ เพื่อแทนอักขระใด ๆ ที่ตำแหน่ง ตัวอย่างเช่นถ้าไดเรกทอรีfooมีไฟล์bar bazและasdfจากนั้นจะขยายไปยังfoo/b*foo/bar foo/baz

ตอนนี้สมมติว่าไดเรกทอรีปัจจุบันมีไฟล์ชื่อihavealongnameและไม่มีอะไรอื่น หากฉันต้องการอ้างอิงไฟล์นี้ฉันอาจพิมพ์*ซึ่งจะแสดงเพียงไฟล์เดียวเท่านั้นแทนที่จะพิมพ์ชื่อเต็ม

หากไดเรกทอรีมีไฟล์ชื่อialsohavealongnameฉันไม่สามารถทำได้*เพราะมันจะตรงกับไฟล์ทั้งสอง ih*ที่ผมจะต้องทำอย่างน้อย

*รูปแบบยังสามารถใช้ได้กับการจับคู่ดังกล่าวข้างต้นไดเรกทอรีไฟล์ฉันกำลังมองหา หากมีเพียงสองไดเรกทอรีfooและbarแต่fooมีเพียงไฟล์bazและbarมีไฟล์asdfผมสามารถจับคู่กับfoo/baz หรือมากยิ่งขึ้นรัดกุม*/baz */b*ถ้าbarว่างเปล่า*/*จะทำงาน

งานของคุณ: กำหนดสตริงของเส้นทางที่เป็นตัวแทนของ "ไดเรกทอรีปัจจุบัน" และเส้นทางเป้าหมายเดียวออกสตริงที่สั้นที่สุดที่เป็นไปได้ที่จะขยายไปยังเส้นทางเป้าหมายนั้นหลังจากขยาย * s

เส้นทางเป้าหมายสามารถใช้เป็นสตริงของตัวเองเป็นดัชนีในอาร์เรย์ของเส้นทางเป็นรายการแรกในอาร์เรย์ของเส้นทางที่ส่งผ่านหรือวิธีที่สะดวกอื่น ๆ ที่ไม่ได้เข้ารหัสยาก ถามในความคิดเห็นหากไม่แน่ใจ

เส้นทางเป้าหมายรับประกันว่าจะมีอยู่ใน "ไดเรกทอรีปัจจุบัน"

คุณสามารถสันนิษฐานได้ว่าเส้นทางทั้งหมดมีเพียงตัวอักษรและตัวเลข ASCII (และ/) คุณอาจใช้เป็นเส้นทางอินพุตที่ถูกรูท (เริ่มต้นด้วย/) หรือญาติ (ไม่ได้ขึ้นต้นด้วย/)

หากมีความเป็นไปได้สั้น ๆ หลายอย่างเท่ากันให้ส่งคืนสิ่งใดสิ่งหนึ่งหรือทั้งหมด

นี่คือ รหัสกอล์ฟไบต์ที่น้อยที่สุดชนะ!

กรณีทดสอบขอบคุณเควิน Cruijssen

Perl 5 , 136 107 102 ไบต์

รวม+2สำหรับn0

ให้รายชื่อไฟล์ใน STDIN อันแรกถือว่าเป็นไฟล์เป้าหมาย

perl -n0E '@a="";for$a(@a){s%%s/(?=$a
)/;/g;$$_//=push@a,map$_.$a,/./g,"\\w*";/^;/>/
;/&&1/!say$a=~s/\\w//gr%e}'
foo/barber/test
foo/barber/testing
foo/barber/coding
foo/test
foo/bar/test
^D

เพียงแค่โค้ดโดยไม่ต้องขึ้นบรรทัดใหม่ตามตัวอักษร:

@a="";for$a(@a){s%%s/(?=$a\n)/;/g;$$_//=push@a,map$_.$a,/./g,"\\w*";/^;/>/\n;/&&1/!say$a=~s/\\w//gr%e}

เกิดปัญหาโดยเจตนาหลังจากพิมพ์โซลูชัน

ยังดูเหมือนยาวเกินไป (การใช้งาน$aและ1/0อึดอัดมาก) แต่เป็นการเริ่มต้นและควรมีประสิทธิภาพพอสมควร

ลองออนไลน์!

มันทำงานอย่างไร

โปรแกรมสร้างผู้สมัคร globs โดยการเติบโตจากด้านหลังไปข้างหน้าเริ่มต้นด้วยสตริงที่ว่างเปล่า มันไม่นี้ในทางที่แรกกว้าง globs ก่อนเพื่อให้มีความยาว 0 จะพยายาม (เฉพาะ ``) แล้วความยาว 1 (เช่นt, i, *) ต่อความยาว 2 (เช่นfb, i*, *g, **) ต่อความยาว 3 และอื่น ๆ จนกว่าจะมีการ glob พบว่าตรงกับเส้นทางแรกเท่านั้น นี่จะเป็นรูปวงกลมที่สั้นที่สุดที่แก้ปัญหาได้ (อาจมีความยาวเท่ากัน)

globs ของความยาวn+1ถูกสร้างขึ้นจาก globs ของความยาวnโดย prepending ตัวละครแต่ละตัวจากรายการของเส้นทางและยัง*อยู่ในด้านหน้าของ glob nความยาวของแต่ละ ดังนั้นเช่นความยาว 3 glob *i*จะมีส่วนร่วมในความยาว 4 globs f*i*, o*i*, o*i*, /*i*, b*i*... s*i*, และในที่สุดt*i* **i*ขอให้สังเกตว่าตัวละครทุกตัวจากรายการเส้นทางเข้าจะถูกเติมไว้แม้ว่ามันจะปรากฏขึ้นหลายครั้งหรือไม่มีเหตุผลก็ตามเพราะมันนำไปสู่บางสิ่งที่ไม่สามารถจับคู่ได้

การทำสิ่งนี้อย่างไร้เดียงสาจะนำไปสู่การระเบิดแบบ combinatorial นั่นคือเหตุผลที่ผู้สมัครทุกคนจะได้รับการประเมินว่ามันมีประโยชน์เพียงใดโดยการพิจารณาว่าจุดใดในเส้นทางที่จะจับคู่ได้ถ้าก้อนนั้นถูกใช้ในตอนท้ายของรูปแบบที่สมบูรณ์ ฉันทำสิ่งนี้โดยการใส่;ที่แต่ละสถานที่ซึ่งเป็นไปได้ของการแข่งขัน เช่นสำหรับ glob t*ฉันจะได้รับสตริง:

foo/barber/;tes;t
foo/barber/;tes;ting
foo/barber/coding
foo/;tes;t
foo/bar/;tes;t

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

ดังนั้นเมื่อพิจารณาถึงความยาวที่nฉันมองฉันจะได้เห็นพลังที่แตกต่าง หากมีการเห็นมาก่อนมีความยาวnหรือสั้นกว่าอีกรูปหนึ่งที่พิจารณาแล้วและขยายตัวดังนั้นรูปนี้จึงไม่มีจุดหมายและถูกตัดออก ประสงค์เช่นนี้ได้รับการกำจัดของผู้สมัครเช่นตั้งแต่อำนาจที่แตกต่างที่เหมือนกันแล้วจะได้รับการมองว่าเป็น**i* *i*นอกจากนี้ยังตัดลูกเล่นที่ผู้สมัครไม่สามารถทำได้เช่นกันf*i*เนื่องจากสตริงที่แตกต่างจะไม่มี;และเป็นเพียงรายการเส้นทางดั้งเดิม จะยอมรับเฉพาะ glob แรกสุดที่เป็นไปไม่ได้เท่านั้นส่วนอื่น ๆ ทั้งหมดจะถูกมองว่ามีพลังที่แตกต่างและจะถูกตัดแต่ง และแม้แต่อันแรกนั้นก็ยังไม่ขยายตัวเนื่องจากการขยายทั้งหมดยังคงเป็นไปไม่ได้และจะถูกตัดเมื่อมีการพิจารณา Simularly in*จะถูกตัดโดยi*ฯลฯ

ข้อมูลด้านบนนำไปสู่การตัดแต่งกิ่งที่ก้าวร้าวมากและโปรแกรมสามารถจัดการกรณีที่ซับซ้อนได้ในเวลาอันสั้น ความไร้ประสิทธิภาพที่สำคัญแม้ว่ามันจะเป็นคำนำหน้าผู้สมัคร globs กับตัวละครที่เป็นไปได้ทั้งหมดไม่เพียง แต่คนที่อยู่ก่อน;ในเส้นทางเส้นทางส่วนหนึ่งของสตริงที่แตกต่าง ตัวละครที่เพิ่มเข้ามาทั้งหมดซึ่งไม่ได้อยู่หน้า a ;จะไม่มีปัญหาเนื่องจากมันนำไปสู่รูปแบบที่เป็นไปไม่ได้ซึ่งจะถูกตัดเมื่อได้รับการพิจารณา แต่ยังคงทิ้งตัวอักษรไว้ก่อน;ในเส้นทางอื่น ดังนั้นในตอนท้ายโปรแกรมนี้ยังสร้าง globs ซึ่งจะสามารถจับคู่กับเส้นทางที่กำหนด มันไม่มีความคิดว่ามันควรจะจดจ่อกับเส้นทางแรก

ตอนนี้ให้พิจารณาวิธีแก้ไขปัญหา ในตัวอย่างที่กำหนดที่อาจเป็น*/*er/tไปได้ สิ่งนี้จะทำให้สตริงที่แตกต่างดังต่อไปนี้:

;f;o;o;/barber/test
foo/barber/testing
foo/barber/coding
foo/test
foo/bar/test

ฉันรู้จักวิธีแก้ปัญหาโดยการมี;ตำแหน่งที่หนึ่ง (เพื่อให้ตรงกับเส้นทางแรก) และไม่ได้;ที่จุดเริ่มต้นของเส้นทางอื่น ๆ (เพื่อให้คนอื่นไม่ตรงกัน)

ด้วยอัลกอริทึมอธิบายตอนนี้ฉันไปที่โปรแกรมจริง:

globs ผู้สมัครจะอยู่ในอาร์เรย์@aที่ฉันวนลูปโดยใช้ตัวแปร$aที่มี glob ปัจจุบันอยู่ระหว่างการพิจารณา แทนที่จะ*ใน glob ฉัน แต่จะใช้\w*เพื่อให้$aเป็นจริง regex แทน glob ฉันจะละเมิดความแปลกประหลาดของ perl for loop ที่คุณสามารถผนวกองค์ประกอบเข้ากับอาร์เรย์ที่ถูกลูปในขณะที่ loop กำลังทำงานและองค์ประกอบใหม่เหล่านี้จะถูกหยิบขึ้นมาในลูป ตั้งแต่เมื่อสร้างความยาวn+1globs ความยาวglobs ทั้งหมดnอยู่ในอาร์เรย์แล้ว@aนี่คือความกว้างก่อน

เนื่องจาก-n0ตัวเลือก (การวนซ้ำโดยนัยเหนืออินพุตทั้งหมด) รายการ$_พา ธจะอยู่ในรูปของสตริงขนาดใหญ่หนึ่งสตริงซึ่งแต่ละเส้นทางถูกยกเลิกด้วยการขึ้นบรรทัดใหม่

@a="";                    Start everything with the length 0 glob
for$a(@a){    }           Loop over candidates in a breadth first way

ภายใน{ }เรามี:

s/(?=$a\n)/;/g            Loop over the paths and insert a ; at every
                          position that the suffix glob can match by
                          looking ahead and checking that the regex
                          under consideration can match up to the end of
                          the path we are in. The distinguishing sting is
                          now in `$_`.

โอ๊ะฉันเพิ่งถูกทำลาย$_และฉันต้องการมันสำหรับการวนรอบต่อไป ดังนั้นให้ห่อโค้ดการทำงานจริงไว้ข้างใน

s%%  ...code.. %e

สิ่งนี้จับคู่สตริงว่างตอนเริ่มต้น$_และอนุญาตให้คุณเรียกใช้รหัสเพื่อกำหนดสิ่งที่จะถูกแทนที่ ถ้าฉันให้แน่ใจว่าที่ประเมินรหัสเป็นสตริงว่าง$_พระทัยในตอนท้ายยังคงไม่เปลี่ยนแปลงแม้ว่าผมจะมีการเปลี่ยนแปลงในช่วง$_code

กลับไปที่หลังจากที่ฉันแทนที่$_ด้วยสตริงที่แตกต่าง:

$$_//= expression

นี่คือ:

$seen{$_} //= expression

//ใน Perl 'defined orมี มันเหมือนไฟฟ้าลัดวงจรที่อาร์กิวเมนต์ที่สองคือการประเมินเฉพาะในกรณีที่หนึ่งคือor undefและสามารถใช้ร่วมกับการบ้านได้เหมือน+=ในภาษาอื่น ดังนั้นหากพวกเขาที่สำคัญ$_ในกัญชา%seenคือundef(ซึ่งก็คือคือสิ่งที่คุณได้รับเมื่อมีการเข้าถึงองค์ประกอบที่ไม่ใช่ที่มีอยู่) $_เพียงแล้วดำเนินการแสดงออกและการกำหนดเป็นค่าคีย์ ดังนั้นหากฉันแน่ใจexpressionว่าไม่ได้ส่งคืนundefสิ่งนั้นโดยทั่วไปหมายถึง "ประเมินการแสดงออกถ้าหากนี่เป็นครั้งแรกที่เราเห็นสตริงพิเศษที่แตกต่าง" และเนื่องจาก$_มีการรับประกันที่จะมี\nมันในความเป็นจริงปลอดภัยที่จะละเมิดแฮชทั่วโลก Perl เพื่อเก็บสตริงที่แตกต่างดังนั้น$$_แทนที่จะ$seen{$_}

สำหรับexpressionฉันใช้:

push@a,map$_.$a,/./g,"\\w*"

โดยพื้นฐาน "สำหรับตัวละครทุกตัว (ยกเว้นการขึ้นบรรทัดใหม่) ในสตริงที่แตกต่างและยังเสริม*ให้กับ glob ปัจจุบันและกดลงบนอาร์เรย์ของ globs ผู้สมัคร" Execpt ฉันใช้\w*สำหรับการ*ที่จะได้รับ regex ที่ถูกต้อง (ฉันสามารถใช้''แทนการ""ที่จะกำจัดของหนึ่งทับขวา แต่แล้วฉันไม่สามารถเรียกใช้รหัสของฉันจากบรรทัดคำสั่ง) โปรดสังเกตว่าสิ่งนี้จะหยิบขึ้นมา;และเพิ่มพวกเขาไปยังผู้สมัคร globs แต่ในภายหลังการทดสอบพวกเขาในการบูรณะ$_ซึ่งไม่มี;ที่จะเป็นอีกครั้งเป็นไปไม่ได้ glob และได้รับการตัดแต่ง

/^;/>/\n;/ &&      If the distinguishing string corresponds to a solution

say$a=~s/\\w//gr   Then replace all \w* back to * and print the solution

1/!                Say returns 1 so this becomes a division by 0.
                   The program exits by crashing after solving it

โปรดสังเกตว่า/^;/>/\n;/มีค่าเทียบเท่ากับสตริงว่างในกรณีที่ยังไม่พบวิธีแก้ปัญหาดังนั้นสิ่งนี้จะทำหน้าที่เป็นสตริงการแทนที่ที่ว่างเปล่าและ$_ได้รับการกู้คืน

Java 10, 854 824 796 738 728 703 688 655 652 647 624 ไบต์

import java.util.*;a->f->{var L=new Stack();List<String>s;int i=999,j,k;for(var t:f.split("/")){s=new java.util.concurrent.CopyOnWriteArrayList();s.add(t);for(k=1;k>0;){k=0;for(var x:s)for(j=0;j<x.length();)if(!s.contains(f=x.substring(0,j)+"~"+x.substring(++j))){s.add(f);k=1;}}for(var x:s)s.add(x.replaceAll("~+","\\*"));L.add(s);}p(L,s=new Stack(),0,f="");for(var y:s){k=0;for(var x:a)if(x.matches(y.replace("*",".*"))&x.split("/").length==y.split("/").length)k++;if(k==1&(j=y.length())<i){f=y;i=j;}}return f;};void p(List L,List r,int d,String c){if(d==L.size())r.add(c);else for(var o:(List)L.get(d))p(L,r,d+1,c+"/"+o);}

สิ่งที่ไม่เป็นระเบียบ .. นี่ไม่ใช่ความท้าทายอย่างง่ายใน Java สามารถเล่นกอล์ฟได้สองสามร้อยไบต์แน่นอน แต่ฉันก็ดีใจที่มันทำงานได้ในที่สุด บอกคุณแล้ว. :)
-5 ไบต์ขอบคุณที่@ceilingcat
-23 ไบต์สลับจาก Java 8 เป็น Java 10

อินพุตเป็นสตริงของเส้นทางไฟล์ (ที่มีไดเรกทอรีเป็นรายการแยกและรายการทั้งหมดที่มีการนำหน้า/) และสตริงที่มีอินพุตไฟล์พา ธ ไปยัง grop

คำอธิบาย:

ลองออนไลน์ (กรณีทดสอบที่มีialsohavealongname/ ihavealongnameaswellยาวลดลงเล็กน้อยและs.add(x.replaceAll("~+","\\*"));ถูกแทนที่ด้วย{s.remove(x);s.add(x.replaceAll("~+","\\*"));}ให้ทำงานใน 5-10 วินาทีสำหรับ TIO แทนที่จะหมดเวลาหลังจาก 60+ วินาที)

import java.util.*;   // Required import for List and Stack

// Method with String-array and String parameters and String return-type
a->f->{
  var L=new Stack();  //  Create a List of Lists
  List<String>s;      //  List of Strings (uninitialized)
  int i=999,j,k;      //  Three integers (`i` starting at 999,
                      //   because 260 is the maximum file-path length in Windows)
  for(var t:f.split("/")){
                      //  Loop over the input file-path split by "/":
    s=new java.util.concurrent.CopyOnWriteArrayList();
                      //  Create a List (which we can modify while iterating it)
    s.add(t);         //  Add the input to this List
    for(k=1;k>0;){    //  Loop as long as there are new items added to the List
      k=0;            //   Reset the newAdded-flag to false
      for(var x:s)    //   And inner loop over the List
        for(j=0;j<t.length();)
                      //    Inner loop `j` in range [0,length-of-item):
          if(!s.contains(f=x.substring(0,j)+"~"+x.substring(++j))){
                      //     Replace the character at index `j` with a '~'
                      //     And if it's a new item:
            s.add(f); //      Add it to the List
            k=1;}}    //      And set the newAdded-flag to true
    for(var x:s)      //  Loop over the List again
      s.add(x.replaceAll("~+","\\*")));
                      //   And replace all 1 or more '~' with a single asterisk
                      //   (NOTE: To reduce bytes it doesn't remove the existing items)
    L.add(s);}        //   Add this List to the List of Lists
  p(L,s=new Stack(),0,"");
                      //  Generate all permutations of the groppings
                      //  (List `s` now contains all groppings of the given file-path)
  for(var y:s){       //  Loop over the groppings in the String-List:
    k=0;              //   Reset integer `k` to 0
    for(var x:a)      //   Inner loop over the input file-paths:
      if(x.matches(y.replace("*",".*"))
                      //    If the current file-path matches the current gropping
         x.split("/").length==y.split("/").length)
                      //    and the amount of slashes are the same:
         k++;         //     Increase integer `k` by 1
    if(k==1           //   If only one of the file-paths matched,
       &(j=y.length())<i){
                      //   and the length is shorter than `i`:
      f=y;            //    Replace the result with this gropping file-path
      i=j;}}          //    And also replace `i` with this shorter `j`
  return f;}          //  Finally return this shortest gropping file-path

// Separated method to generate gropping file-path permutations given a List of Lists
void p(List L,List r,int d,String c){
  if(d==L.size())     //  If we've reached the final depth
    r.add(c);         //   Add the current gropping-file path to the result-List
  else                //  Else:
    for(var o:(List)L.get(d))
                      //   Loop over the List of the current depth:
      p(L,r,d+1,      //    Recursive call with depth+1,
        c+"/"+o);}    //    and current + "/" + item of loop

คำอธิบายทั่วไปเพิ่มเติม:

ตัวอย่าง: ลองทำ/foo, /foo/bar, /foo/barber, /foo/bar/test, /foo/barber/test, /foo/barber/testing, /foo/barber/coding, /foo/testตามไฟล์พา ธที่กำหนดและfoo/bar/testเป็นไฟล์พา ธ ไปยัง grop

1) ฉันเริ่มต้นด้วยการแยกอินพุตพา ธ ไฟล์โดย/และสร้างไฟล์ groppings ทั้งหมดของคำที่แยกกันเหล่านี้:

foo: [foo, *oo, f*o, fo*, *o, *o*, f*, *]
bar: [bar, *ar, b*r, ba*, *r, *a*, b*, *]
test: [test, *est, t*st, te*t, tes*, *st, *e*t, *es*, t*t, t*s*, te*, *t, *s*, *e*, t*, *]

2) ฉันสร้างพีชคณิตทั้งหมดด้วยคำเหล่านี้ในลำดับเดียวกัน (นำมาใช้ใหม่/ในระหว่างและที่ด้านหน้า):

[/foo/bar/test, /foo/bar/*est, /foo/bar/t*st, /foo/bar/te*t, /foo/bar/tes*, /foo/bar/*st, /foo/bar/*e*t, /foo/bar/*es*, /foo/bar/t*t, /foo/bar/t*s*, /foo/bar/te*, /foo/bar/*t, /foo/bar/*s*, /foo/bar/*e*, /foo/bar/t*, /foo/bar/*, /foo/*ar/test, /foo/*ar/*est, /foo/*ar/t*st, /foo/*ar/te*t, /foo/*ar/tes*, /foo/*ar/*st, /foo/*ar/*e*t, /foo/*ar/*es*, /foo/*ar/t*t, /foo/*ar/t*s*, /foo/*ar/te*, /foo/*ar/*t, /foo/*ar/*s*, /foo/*ar/*e*, /foo/*ar/t*, /foo/*ar/*, /foo/b*r/test, /foo/b*r/*est, /foo/b*r/t*st, /foo/b*r/te*t, /foo/b*r/tes*, /foo/b*r/*st, /foo/b*r/*e*t, /foo/b*r/*es*, /foo/b*r/t*t, /foo/b*r/t*s*, /foo/b*r/te*, /foo/b*r/*t, /foo/b*r/*s*, /foo/b*r/*e*, /foo/b*r/t*, /foo/b*r/*, /foo/ba*/test, /foo/ba*/*est, /foo/ba*/t*st, /foo/ba*/te*t, /foo/ba*/tes*, /foo/ba*/*st, /foo/ba*/*e*t, /foo/ba*/*es*, /foo/ba*/t*t, /foo/ba*/t*s*, /foo/ba*/te*, /foo/ba*/*t, /foo/ba*/*s*, /foo/ba*/*e*, /foo/ba*/t*, /foo/ba*/*, /foo/*r/test, /foo/*r/*est, /foo/*r/t*st, /foo/*r/te*t, /foo/*r/tes*, /foo/*r/*st, /foo/*r/*e*t, /foo/*r/*es*, /foo/*r/t*t, /foo/*r/t*s*, /foo/*r/te*, /foo/*r/*t, /foo/*r/*s*, /foo/*r/*e*, /foo/*r/t*, /foo/*r/*, /foo/*a*/test, /foo/*a*/*est, /foo/*a*/t*st, /foo/*a*/te*t, /foo/*a*/tes*, /foo/*a*/*st, /foo/*a*/*e*t, /foo/*a*/*es*, /foo/*a*/t*t, /foo/*a*/t*s*, /foo/*a*/te*, /foo/*a*/*t, /foo/*a*/*s*, /foo/*a*/*e*, /foo/*a*/t*, /foo/*a*/*, /foo/b*/test, /foo/b*/*est, /foo/b*/t*st, /foo/b*/te*t, /foo/b*/tes*, /foo/b*/*st, /foo/b*/*e*t, /foo/b*/*es*, /foo/b*/t*t, /foo/b*/t*s*, /foo/b*/te*, /foo/b*/*t, /foo/b*/*s*, /foo/b*/*e*, /foo/b*/t*, /foo/b*/*, /foo/*/test, /foo/*/*est, /foo/*/t*st, /foo/*/te*t, /foo/*/tes*, /foo/*/*st, /foo/*/*e*t, /foo/*/*es*, /foo/*/t*t, /foo/*/t*s*, /foo/*/te*, /foo/*/*t, /foo/*/*s*, /foo/*/*e*, /foo/*/t*, /foo/*/*, /*oo/bar/test, /*oo/bar/*est, /*oo/bar/t*st, /*oo/bar/te*t, /*oo/bar/tes*, /*oo/bar/*st, /*oo/bar/*e*t, /*oo/bar/*es*, /*oo/bar/t*t, /*oo/bar/t*s*, /*oo/bar/te*, /*oo/bar/*t, /*oo/bar/*s*, /*oo/bar/*e*, /*oo/bar/t*, /*oo/bar/*, /*oo/*ar/test, /*oo/*ar/*est, /*oo/*ar/t*st, /*oo/*ar/te*t, /*oo/*ar/tes*, /*oo/*ar/*st, /*oo/*ar/*e*t, /*oo/*ar/*es*, /*oo/*ar/t*t, /*oo/*ar/t*s*, /*oo/*ar/te*, /*oo/*ar/*t, /*oo/*ar/*s*, /*oo/*ar/*e*, /*oo/*ar/t*, /*oo/*ar/*, /*oo/b*r/test, /*oo/b*r/*est, /*oo/b*r/t*st, /*oo/b*r/te*t, /*oo/b*r/tes*, /*oo/b*r/*st, /*oo/b*r/*e*t, /*oo/b*r/*es*, /*oo/b*r/t*t, /*oo/b*r/t*s*, /*oo/b*r/te*, /*oo/b*r/*t, /*oo/b*r/*s*, /*oo/b*r/*e*, /*oo/b*r/t*, /*oo/b*r/*, /*oo/ba*/test, /*oo/ba*/*est, /*oo/ba*/t*st, /*oo/ba*/te*t, /*oo/ba*/tes*, /*oo/ba*/*st, /*oo/ba*/*e*t, /*oo/ba*/*es*, /*oo/ba*/t*t, /*oo/ba*/t*s*, /*oo/ba*/te*, /*oo/ba*/*t, /*oo/ba*/*s*, /*oo/ba*/*e*, /*oo/ba*/t*, /*oo/ba*/*, /*oo/*r/test, /*oo/*r/*est, /*oo/*r/t*st, /*oo/*r/te*t, /*oo/*r/tes*, /*oo/*r/*st, /*oo/*r/*e*t, /*oo/*r/*es*, /*oo/*r/t*t, /*oo/*r/t*s*, /*oo/*r/te*, /*oo/*r/*t, /*oo/*r/*s*, /*oo/*r/*e*, /*oo/*r/t*, /*oo/*r/*, /*oo/*a*/test, /*oo/*a*/*est, /*oo/*a*/t*st, /*oo/*a*/te*t, /*oo/*a*/tes*, /*oo/*a*/*st, /*oo/*a*/*e*t, /*oo/*a*/*es*, /*oo/*a*/t*t, /*oo/*a*/t*s*, /*oo/*a*/te*, /*oo/*a*/*t, /*oo/*a*/*s*, /*oo/*a*/*e*, /*oo/*a*/t*, /*oo/*a*/*, /*oo/b*/test, /*oo/b*/*est, /*oo/b*/t*st, /*oo/b*/te*t, /*oo/b*/tes*, /*oo/b*/*st, /*oo/b*/*e*t, /*oo/b*/*es*, /*oo/b*/t*t, /*oo/b*/t*s*, /*oo/b*/te*, /*oo/b*/*t, /*oo/b*/*s*, /*oo/b*/*e*, /*oo/b*/t*, /*oo/b*/*, /*oo/*/test, /*oo/*/*est, /*oo/*/t*st, /*oo/*/te*t, /*oo/*/tes*, /*oo/*/*st, /*oo/*/*e*t, /*oo/*/*es*, /*oo/*/t*t, /*oo/*/t*s*, /*oo/*/te*, /*oo/*/*t, /*oo/*/*s*, /*oo/*/*e*, /*oo/*/t*, /*oo/*/*, /f*o/bar/test, /f*o/bar/*est, /f*o/bar/t*st, /f*o/bar/te*t, /f*o/bar/tes*, /f*o/bar/*st, /f*o/bar/*e*t, /f*o/bar/*es*, /f*o/bar/t*t, /f*o/bar/t*s*, /f*o/bar/te*, /f*o/bar/*t, /f*o/bar/*s*, /f*o/bar/*e*, /f*o/bar/t*, /f*o/bar/*, /f*o/*ar/test, /f*o/*ar/*est, /f*o/*ar/t*st, /f*o/*ar/te*t, /f*o/*ar/tes*, /f*o/*ar/*st, /f*o/*ar/*e*t, /f*o/*ar/*es*, /f*o/*ar/t*t, /f*o/*ar/t*s*, /f*o/*ar/te*, /f*o/*ar/*t, /f*o/*ar/*s*, /f*o/*ar/*e*, /f*o/*ar/t*, /f*o/*ar/*, /f*o/b*r/test, /f*o/b*r/*est, /f*o/b*r/t*st, /f*o/b*r/te*t, /f*o/b*r/tes*, /f*o/b*r/*st, /f*o/b*r/*e*t, /f*o/b*r/*es*, /f*o/b*r/t*t, /f*o/b*r/t*s*, /f*o/b*r/te*, /f*o/b*r/*t, /f*o/b*r/*s*, /f*o/b*r/*e*, /f*o/b*r/t*, /f*o/b*r/*, /f*o/ba*/test, /f*o/ba*/*est, /f*o/ba*/t*st, /f*o/ba*/te*t, /f*o/ba*/tes*, /f*o/ba*/*st, /f*o/ba*/*e*t, /f*o/ba*/*es*, /f*o/ba*/t*t, /f*o/ba*/t*s*, /f*o/ba*/te*, /f*o/ba*/*t, /f*o/ba*/*s*, /f*o/ba*/*e*, /f*o/ba*/t*, /f*o/ba*/*, /f*o/*r/test, /f*o/*r/*est, /f*o/*r/t*st, /f*o/*r/te*t, /f*o/*r/tes*, /f*o/*r/*st, /f*o/*r/*e*t, /f*o/*r/*es*, /f*o/*r/t*t, /f*o/*r/t*s*, /f*o/*r/te*, /f*o/*r/*t, /f*o/*r/*s*, /f*o/*r/*e*, /f*o/*r/t*, /f*o/*r/*, /f*o/*a*/test, /f*o/*a*/*est, /f*o/*a*/t*st, /f*o/*a*/te*t, /f*o/*a*/tes*, /f*o/*a*/*st, /f*o/*a*/*e*t, /f*o/*a*/*es*, /f*o/*a*/t*t, /f*o/*a*/t*s*, /f*o/*a*/te*, /f*o/*a*/*t, /f*o/*a*/*s*, /f*o/*a*/*e*, /f*o/*a*/t*, /f*o/*a*/*, /f*o/b*/test, /f*o/b*/*est, /f*o/b*/t*st, /f*o/b*/te*t, /f*o/b*/tes*, /f*o/b*/*st, /f*o/b*/*e*t, /f*o/b*/*es*, /f*o/b*/t*t, /f*o/b*/t*s*, /f*o/b*/te*, /f*o/b*/*t, /f*o/b*/*s*, /f*o/b*/*e*, /f*o/b*/t*, /f*o/b*/*, /f*o/*/test, /f*o/*/*est, /f*o/*/t*st, /f*o/*/te*t, /f*o/*/tes*, /f*o/*/*st, /f*o/*/*e*t, /f*o/*/*es*, /f*o/*/t*t, /f*o/*/t*s*, /f*o/*/te*, /f*o/*/*t, /f*o/*/*s*, /f*o/*/*e*, /f*o/*/t*, /f*o/*/*, /fo*/bar/test, /fo*/bar/*est, /fo*/bar/t*st, /fo*/bar/te*t, /fo*/bar/tes*, /fo*/bar/*st, /fo*/bar/*e*t, /fo*/bar/*es*, /fo*/bar/t*t, /fo*/bar/t*s*, /fo*/bar/te*, /fo*/bar/*t, /fo*/bar/*s*, /fo*/bar/*e*, /fo*/bar/t*, /fo*/bar/*, /fo*/*ar/test, /fo*/*ar/*est, /fo*/*ar/t*st, /fo*/*ar/te*t, /fo*/*ar/tes*, /fo*/*ar/*st, /fo*/*ar/*e*t, /fo*/*ar/*es*, /fo*/*ar/t*t, /fo*/*ar/t*s*, /fo*/*ar/te*, /fo*/*ar/*t, /fo*/*ar/*s*, /fo*/*ar/*e*, /fo*/*ar/t*, /fo*/*ar/*, /fo*/b*r/test, /fo*/b*r/*est, /fo*/b*r/t*st, /fo*/b*r/te*t, /fo*/b*r/tes*, /fo*/b*r/*st, /fo*/b*r/*e*t, /fo*/b*r/*es*, /fo*/b*r/t*t, /fo*/b*r/t*s*, /fo*/b*r/te*, /fo*/b*r/*t, /fo*/b*r/*s*, /fo*/b*r/*e*, /fo*/b*r/t*, /fo*/b*r/*, /fo*/ba*/test, /fo*/ba*/*est, /fo*/ba*/t*st, /fo*/ba*/te*t, /fo*/ba*/tes*, /fo*/ba*/*st, /fo*/ba*/*e*t, /fo*/ba*/*es*, /fo*/ba*/t*t, /fo*/ba*/t*s*, /fo*/ba*/te*, /fo*/ba*/*t, /fo*/ba*/*s*, /fo*/ba*/*e*, /fo*/ba*/t*, /fo*/ba*/*, /fo*/*r/test, /fo*/*r/*est, /fo*/*r/t*st, /fo*/*r/te*t, /fo*/*r/tes*, /fo*/*r/*st, /fo*/*r/*e*t, /fo*/*r/*es*, /fo*/*r/t*t, /fo*/*r/t*s*, /fo*/*r/te*, /fo*/*r/*t, /fo*/*r/*s*, /fo*/*r/*e*, /fo*/*r/t*, /fo*/*r/*, /fo*/*a*/test, /fo*/*a*/*est, /fo*/*a*/t*st, /fo*/*a*/te*t, /fo*/*a*/tes*, /fo*/*a*/*st, /fo*/*a*/*e*t, /fo*/*a*/*es*, /fo*/*a*/t*t, /fo*/*a*/t*s*, /fo*/*a*/te*, /fo*/*a*/*t, /fo*/*a*/*s*, /fo*/*a*/*e*, /fo*/*a*/t*, /fo*/*a*/*, /fo*/b*/test, /fo*/b*/*est, /fo*/b*/t*st, /fo*/b*/te*t, /fo*/b*/tes*, /fo*/b*/*st, /fo*/b*/*e*t, /fo*/b*/*es*, /fo*/b*/t*t, /fo*/b*/t*s*, /fo*/b*/te*, /fo*/b*/*t, /fo*/b*/*s*, /fo*/b*/*e*, /fo*/b*/t*, /fo*/b*/*, /fo*/*/test, /fo*/*/*est, /fo*/*/t*st, /fo*/*/te*t, /fo*/*/tes*, /fo*/*/*st, /fo*/*/*e*t, /fo*/*/*es*, /fo*/*/t*t, /fo*/*/t*s*, /fo*/*/te*, /fo*/*/*t, /fo*/*/*s*, /fo*/*/*e*, /fo*/*/t*, /fo*/*/*, /*o/bar/test, /*o/bar/*est, /*o/bar/t*st, /*o/bar/te*t, /*o/bar/tes*, /*o/bar/*st, /*o/bar/*e*t, /*o/bar/*es*, /*o/bar/t*t, /*o/bar/t*s*, /*o/bar/te*, /*o/bar/*t, /*o/bar/*s*, /*o/bar/*e*, /*o/bar/t*, /*o/bar/*, /*o/*ar/test, /*o/*ar/*est, /*o/*ar/t*st, /*o/*ar/te*t, /*o/*ar/tes*, /*o/*ar/*st, /*o/*ar/*e*t, /*o/*ar/*es*, /*o/*ar/t*t, /*o/*ar/t*s*, /*o/*ar/te*, /*o/*ar/*t, /*o/*ar/*s*, /*o/*ar/*e*, /*o/*ar/t*, /*o/*ar/*, /*o/b*r/test, /*o/b*r/*est, /*o/b*r/t*st, /*o/b*r/te*t, /*o/b*r/tes*, /*o/b*r/*st, /*o/b*r/*e*t, /*o/b*r/*es*, /*o/b*r/t*t, /*o/b*r/t*s*, /*o/b*r/te*, /*o/b*r/*t, /*o/b*r/*s*, /*o/b*r/*e*, /*o/b*r/t*, /*o/b*r/*, /*o/ba*/test, /*o/ba*/*est, /*o/ba*/t*st, /*o/ba*/te*t, /*o/ba*/tes*, /*o/ba*/*st, /*o/ba*/*e*t, /*o/ba*/*es*, /*o/ba*/t*t, /*o/ba*/t*s*, /*o/ba*/te*, /*o/ba*/*t, /*o/ba*/*s*, /*o/ba*/*e*, /*o/ba*/t*, /*o/ba*/*, /*o/*r/test, /*o/*r/*est, /*o/*r/t*st, /*o/*r/te*t, /*o/*r/tes*, /*o/*r/*st, /*o/*r/*e*t, /*o/*r/*es*, /*o/*r/t*t, /*o/*r/t*s*, /*o/*r/te*, /*o/*r/*t, /*o/*r/*s*, /*o/*r/*e*, /*o/*r/t*, /*o/*r/*, /*o/*a*/test, /*o/*a*/*est, /*o/*a*/t*st, /*o/*a*/te*t, /*o/*a*/tes*, /*o/*a*/*st, /*o/*a*/*e*t, /*o/*a*/*es*, /*o/*a*/t*t, /*o/*a*/t*s*, /*o/*a*/te*, /*o/*a*/*t, /*o/*a*/*s*, /*o/*a*/*e*, /*o/*a*/t*, /*o/*a*/*, /*o/b*/test, /*o/b*/*est, /*o/b*/t*st, /*o/b*/te*t, /*o/b*/tes*, /*o/b*/*st, /*o/b*/*e*t, /*o/b*/*es*, /*o/b*/t*t, /*o/b*/t*s*, /*o/b*/te*, /*o/b*/*t, /*o/b*/*s*, /*o/b*/*e*, /*o/b*/t*, /*o/b*/*, /*o/*/test, /*o/*/*est, /*o/*/t*st, /*o/*/te*t, /*o/*/tes*, /*o/*/*st, /*o/*/*e*t, /*o/*/*es*, /*o/*/t*t, /*o/*/t*s*, /*o/*/te*, /*o/*/*t, /*o/*/*s*, /*o/*/*e*, /*o/*/t*, /*o/*/*, /*o*/bar/test, /*o*/bar/*est, /*o*/bar/t*st, /*o*/bar/te*t, /*o*/bar/tes*, /*o*/bar/*st, /*o*/bar/*e*t, /*o*/bar/*es*, /*o*/bar/t*t, /*o*/bar/t*s*, /*o*/bar/te*, /*o*/bar/*t, /*o*/bar/*s*, /*o*/bar/*e*, /*o*/bar/t*, /*o*/bar/*, /*o*/*ar/test, /*o*/*ar/*est, /*o*/*ar/t*st, /*o*/*ar/te*t, /*o*/*ar/tes*, /*o*/*ar/*st, /*o*/*ar/*e*t, /*o*/*ar/*es*, /*o*/*ar/t*t, /*o*/*ar/t*s*, /*o*/*ar/te*, /*o*/*ar/*t, /*o*/*ar/*s*, /*o*/*ar/*e*, /*o*/*ar/t*, /*o*/*ar/*, /*o*/b*r/test, /*o*/b*r/*est, /*o*/b*r/t*st, /*o*/b*r/te*t, /*o*/b*r/tes*, /*o*/b*r/*st, /*o*/b*r/*e*t, /*o*/b*r/*es*, /*o*/b*r/t*t, /*o*/b*r/t*s*, /*o*/b*r/te*, /*o*/b*r/*t, /*o*/b*r/*s*, /*o*/b*r/*e*, /*o*/b*r/t*, /*o*/b*r/*, /*o*/ba*/test, /*o*/ba*/*est, /*o*/ba*/t*st, /*o*/ba*/te*t, /*o*/ba*/tes*, /*o*/ba*/*st, /*o*/ba*/*e*t, /*o*/ba*/*es*, /*o*/ba*/t*t, /*o*/ba*/t*s*, /*o*/ba*/te*, /*o*/ba*/*t, /*o*/ba*/*s*, /*o*/ba*/*e*, /*o*/ba*/t*, /*o*/ba*/*, /*o*/*r/test, /*o*/*r/*est, /*o*/*r/t*st, /*o*/*r/te*t, /*o*/*r/tes*, /*o*/*r/*st, /*o*/*r/*e*t, /*o*/*r/*es*, /*o*/*r/t*t, /*o*/*r/t*s*, /*o*/*r/te*, /*o*/*r/*t, /*o*/*r/*s*, /*o*/*r/*e*, /*o*/*r/t*, /*o*/*r/*, /*o*/*a*/test, /*o*/*a*/*est, /*o*/*a*/t*st, /*o*/*a*/te*t, /*o*/*a*/tes*, /*o*/*a*/*st, /*o*/*a*/*e*t, /*o*/*a*/*es*, /*o*/*a*/t*t, /*o*/*a*/t*s*, /*o*/*a*/te*, /*o*/*a*/*t, /*o*/*a*/*s*, /*o*/*a*/*e*, /*o*/*a*/t*, /*o*/*a*/*, /*o*/b*/test, /*o*/b*/*est, /*o*/b*/t*st, /*o*/b*/te*t, /*o*/b*/tes*, /*o*/b*/*st, /*o*/b*/*e*t, /*o*/b*/*es*, /*o*/b*/t*t, /*o*/b*/t*s*, /*o*/b*/te*, /*o*/b*/*t, /*o*/b*/*s*, /*o*/b*/*e*, /*o*/b*/t*, /*o*/b*/*, /*o*/*/test, /*o*/*/*est, /*o*/*/t*st, /*o*/*/te*t, /*o*/*/tes*, /*o*/*/*st, /*o*/*/*e*t, /*o*/*/*es*, /*o*/*/t*t, /*o*/*/t*s*, /*o*/*/te*, /*o*/*/*t, /*o*/*/*s*, /*o*/*/*e*, /*o*/*/t*, /*o*/*/*, /f*/bar/test, /f*/bar/*est, /f*/bar/t*st, /f*/bar/te*t, /f*/bar/tes*, /f*/bar/*st, /f*/bar/*e*t, /f*/bar/*es*, /f*/bar/t*t, /f*/bar/t*s*, /f*/bar/te*, /f*/bar/*t, /f*/bar/*s*, /f*/bar/*e*, /f*/bar/t*, /f*/bar/*, /f*/*ar/test, /f*/*ar/*est, /f*/*ar/t*st, /f*/*ar/te*t, /f*/*ar/tes*, /f*/*ar/*st, /f*/*ar/*e*t, /f*/*ar/*es*, /f*/*ar/t*t, /f*/*ar/t*s*, /f*/*ar/te*, /f*/*ar/*t, /f*/*ar/*s*, /f*/*ar/*e*, /f*/*ar/t*, /f*/*ar/*, /f*/b*r/test, /f*/b*r/*est, /f*/b*r/t*st, /f*/b*r/te*t, /f*/b*r/tes*, /f*/b*r/*st, /f*/b*r/*e*t, /f*/b*r/*es*, /f*/b*r/t*t, /f*/b*r/t*s*, /f*/b*r/te*, /f*/b*r/*t, /f*/b*r/*s*, /f*/b*r/*e*, /f*/b*r/t*, /f*/b*r/*, /f*/ba*/test, /f*/ba*/*est, /f*/ba*/t*st, /f*/ba*/te*t, /f*/ba*/tes*, /f*/ba*/*st, /f*/ba*/*e*t, /f*/ba*/*es*, /f*/ba*/t*t, /f*/ba*/t*s*, /f*/ba*/te*, /f*/ba*/*t, /f*/ba*/*s*, /f*/ba*/*e*, /f*/ba*/t*, /f*/ba*/*, /f*/*r/test, /f*/*r/*est, /f*/*r/t*st, /f*/*r/te*t, /f*/*r/tes*, /f*/*r/*st, /f*/*r/*e*t, /f*/*r/*es*, /f*/*r/t*t, /f*/*r/t*s*, /f*/*r/te*, /f*/*r/*t, /f*/*r/*s*, /f*/*r/*e*, /f*/*r/t*, /f*/*r/*, /f*/*a*/test, /f*/*a*/*est, /f*/*a*/t*st, /f*/*a*/te*t, /f*/*a*/tes*, /f*/*a*/*st, /f*/*a*/*e*t, /f*/*a*/*es*, /f*/*a*/t*t, /f*/*a*/t*s*, /f*/*a*/te*, /f*/*a*/*t, /f*/*a*/*s*, /f*/*a*/*e*, /f*/*a*/t*, /f*/*a*/*, /f*/b*/test, /f*/b*/*est, /f*/b*/t*st, /f*/b*/te*t, /f*/b*/tes*, /f*/b*/*st, /f*/b*/*e*t, /f*/b*/*es*, /f*/b*/t*t, /f*/b*/t*s*, /f*/b*/te*, /f*/b*/*t, /f*/b*/*s*, /f*/b*/*e*, /f*/b*/t*, /f*/b*/*, /f*/*/test, /f*/*/*est, /f*/*/t*st, /f*/*/te*t, /f*/*/tes*, /f*/*/*st, /f*/*/*e*t, /f*/*/*es*, /f*/*/t*t, /f*/*/t*s*, /f*/*/te*, /f*/*/*t, /f*/*/*s*, /f*/*/*e*, /f*/*/t*, /f*/*/*, /*/bar/test, /*/bar/*est, /*/bar/t*st, /*/bar/te*t, /*/bar/tes*, /*/bar/*st, /*/bar/*e*t, /*/bar/*es*, /*/bar/t*t, /*/bar/t*s*, /*/bar/te*, /*/bar/*t, /*/bar/*s*, /*/bar/*e*, /*/bar/t*, /*/bar/*, /*/*ar/test, /*/*ar/*est, /*/*ar/t*st, /*/*ar/te*t, /*/*ar/tes*, /*/*ar/*st, /*/*ar/*e*t, /*/*ar/*es*, /*/*ar/t*t, /*/*ar/t*s*, /*/*ar/te*, /*/*ar/*t, /*/*ar/*s*, /*/*ar/*e*, /*/*ar/t*, /*/*ar/*, /*/b*r/test, /*/b*r/*est, /*/b*r/t*st, /*/b*r/te*t, /*/b*r/tes*, /*/b*r/*st, /*/b*r/*e*t, /*/b*r/*es*, /*/b*r/t*t, /*/b*r/t*s*, /*/b*r/te*, /*/b*r/*t, /*/b*r/*s*, /*/b*r/*e*, /*/b*r/t*, /*/b*r/*, /*/ba*/test, /*/ba*/*est, /*/ba*/t*st, /*/ba*/te*t, /*/ba*/tes*, /*/ba*/*st, /*/ba*/*e*t, /*/ba*/*es*, /*/ba*/t*t, /*/ba*/t*s*, /*/ba*/te*, /*/ba*/*t, /*/ba*/*s*, /*/ba*/*e*, /*/ba*/t*, /*/ba*/*, /*/*r/test, /*/*r/*est, /*/*r/t*st, /*/*r/te*t, /*/*r/tes*, /*/*r/*st, /*/*r/*e*t, /*/*r/*es*, /*/*r/t*t, /*/*r/t*s*, /*/*r/te*, /*/*r/*t, /*/*r/*s*, /*/*r/*e*, /*/*r/t*, /*/*r/*, /*/*a*/test, /*/*a*/*est, /*/*a*/t*st, /*/*a*/te*t, /*/*a*/tes*, /*/*a*/*st, /*/*a*/*e*t, /*/*a*/*es*, /*/*a*/t*t, /*/*a*/t*s*, /*/*a*/te*, /*/*a*/*t, /*/*a*/*s*, /*/*a*/*e*, /*/*a*/t*, /*/*a*/*, /*/b*/test, /*/b*/*est, /*/b*/t*st, /*/b*/te*t, /*/b*/tes*, /*/b*/*st, /*/b*/*e*t, /*/b*/*es*, /*/b*/t*t, /*/b*/t*s*, /*/b*/te*, /*/b*/*t, /*/b*/*s*, /*/b*/*e*, /*/b*/t*, /*/b*/*, /*/*/test, /*/*/*est, /*/*/t*st, /*/*/te*t, /*/*/tes*, /*/*/*st, /*/*/*e*t, /*/*/*es*, /*/*/t*t, /*/*/t*s*, /*/*/te*, /*/*/*t, /*/*/*s*, /*/*/*e*, /*/*/t*, /*/*/*]

3) จากนั้นฉันวนซ้ำรายการในรายการด้านบนและตรวจสอบว่าตรงกับเส้นทางไฟล์เดียวในอาร์เรย์อินพุตของเส้นทางไฟล์ (ฉันทำสิ่งนี้โดยการตรวจสอบสองสิ่ง: คือจำนวนสแลชเดียวกันและไม่ตรงกับ regex ที่*ถูกแทนที่ด้วยทุกครั้ง.*)
ถ้าเป็นเช่นนั้น: ให้สั้นที่สุดก่อน