शैल ग्लोब गोल्फिंग


11

यह कार्य ग्लोब विस्तार के बाद, एक फ़ाइल के लिए सबसे छोटा रास्ता आउटपुट करना है।

शेल ग्लोबिंग क्या है? अधिकांश गोले में, आप *स्थिति में किसी भी वर्ण का प्रतिनिधित्व करने के लिए एक पथ में चरित्र का उपयोग कर सकते हैं । उदाहरण के लिए, यदि निर्देशिका 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 (और /s) हैं। आप उन इनपुट पथों के रूप में ले सकते हैं जो रूट किए गए हैं (प्रारंभ करें /) या सापेक्ष (प्रारंभ न करें /)।

यदि कई समान रूप से कम संभावनाएं हैं, तो उनमें से किसी को या सभी को वापस करें।

ये है , सबसे कम बाइट्स जीतता है!

टेस्ट मामलों , केविन क्रूज़सेन के लिए धन्यवाद ।


4
तो हम मान सकते हैं फ़ाइल नाम रिक्तियां नहीं होती हैं, नई-पंक्तियों, बैकस्लैश, *, ?, [ आदि? यह शायद सबसे आसान होगा यदि आप सिर्फ यह
बताएं

3
वास्तविक डिस्क I / O भाग कई भाषाओं में उबाऊ होगा। जैसे पर्ल में मैं सिर्फ फ़ाइल नाम लेने के लिए और से सभी पथ घटकों की जगह लेंगे *और रन पर्ल globसभी फ़ाइल नाम कि प्रासंगिक हो सकता है पाने के लिए (उदाहरण के लिए foo/bar/bazहो जाता है */*/*)। उसके बाद यह एक स्ट्रिंग प्रसंस्करण चुनौती बन जाता है। और यह चुनौती पहले से ही काफी कठिन है। मुझे लगता है कि यह चुनौती साफ/
सुथरी

1
@KevinCruijssen निश्चित रूप से, यह एक मजेदार चुनौती है और ज्यादातर शुद्ध गोल्फिंग भाषाओं को दूर रखना चाहिए, मुझे लगता है कि आपको एक वास्तविक कार्यक्रम की आवश्यकता होगी (जब तक कि आप सभी संभावित तारों को उत्पन्न न करें जब तक कि आप सबसे कम हिट न करें जो काम उबाऊ है और घातीय विस्फोट होगा) आपके वर्तमान उदाहरण बमुश्किल उन मामलों को कवर करना शुरू करें जिन्हें आपको संभालने की आवश्यकता है। उपयोग: यहाँ परागकोष मामला है a*fका चयन करने के azzfसे azzf, azzg, bzzf। वसीयत का विस्तार करने के लिए a*b*c..
टन इंजील

2
@ टोनहॉस्पेल मैं आश्वस्त हूं। अब आप इनपुट के रूप में पथों की एक सरणी लेते हैं।
पावेल

4
@ WeijunZhou मैंने इनपुट के बारे में अपना विचार बदल दिया है। अब आप पथों की एक सरणी ले सकते हैं।
पावेल

जवाबों:


8

पर्ल 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बहुत ही अजीब कर रहे हैं), लेकिन यह एक शुरुआत है और यथोचित कुशल होना चाहिए।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

कार्यक्रम खाली स्ट्रिंग के साथ शुरू करने के लिए उन्हें पीछे से आगे बढ़ते हुए उम्मीदवार ग्लब्स बनाता है। यह इस एक चौड़ाई पहले रास्ते में, लंबाई 0 की तो पहले globs आज़माया गया है करता है (केवल ``), तो लंबाई 1 (जैसे t, i, *), अगले लंबाई 2 (जैसे fb, i*, *g, **), और इतने पर अगले लंबाई 3 जब तक एक ग्लोब पाया जाता है कि केवल पहले रास्ते से मेल खाता है। यह तब समस्या को हल करने वाला सबसे छोटा गोला होगा (उसी लंबाई के अन्य मौजूद हो सकते हैं)।

लंबाई के globs n+1लंबाई के globs से उत्पन्न होते हैं nपथों की सूची से हर किरदार prepending द्वारा और भी *लंबाई के प्रत्येक ग्लोब के सामने n। तो जैसे लंबाई 3 ग्लोब *i*लंबाई 4 globs योगदान देगा f*i*, o*i*, o*i*, /*i*, b*i*... s*i*, t*i*और अंत में **i*। ध्यान दें कि इनपुट पथों की सूची में से प्रत्येक वर्ण भले ही कई बार दिखाई देता हो या जो कुछ भी समझ में न आता हो, क्योंकि यह कुछ ऐसा होता है जो कभी मेल नहीं खाता है।

भोलेपन से ऐसा करने से एक विस्फोट होगा। इसीलिए हर उम्मीदवार के लिए यह आकलन किया जाता है कि यह निर्धारित करने के लिए कि यह उन बिंदुओं पर कितना उपयोगी है, जिन मार्गों में यह मेल खा सकता है, अगर ग्लोब का उपयोग पूर्ण ग्लोब के अंत में किया गया था। मैं ;प्रत्येक स्थान पर एक मैच सम्मिलित करके ऐसा करता हूं जहां एक मैच संभव है। ग्लोब के लिए उदाहरण के लिए t*मुझे स्ट्रिंग मिलेगा:

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

यह ग्लोब की "विशिष्ट शक्ति" का प्रतिनिधित्व करता है। हर गोला जिसमें बिल्कुल समान शक्ति है, उतना ही अच्छा है। यदि आप एक पूर्ण ग्लोब के अंत में उन्हें एक-दूसरे द्वारा प्रतिस्थापित करते हैं तो वे सभी एक ही पथ से मेल खाएंगे। तो आप बस के रूप में अच्छी तरह से कम से कम एक का उपयोग कर सकते हैं।

इसलिए जब लंबाई वाले nग्लब्स पर विचार करते हैं, तो मैं पहली बार इसकी विशिष्ट शक्ति को देखता हूं। यदि यह पहले देखा गया है कि लंबाई का एक और गोला nया छोटा था जिसे पहले से ही माना गया था और विस्तारित किया गया था, तो यह ग्लोब व्यर्थ है और छंट जाता है। यह उदाहरण के लिए उम्मीदवारों **i*से छुटकारा पाने के लिए होगा, क्योंकि समान शक्ति पहले से ही देखी जाएगी *i*। यह भी असंभव उम्मीदवारों की तरह लगता है f*i*क्योंकि विशिष्ट स्ट्रिंग में कोई नहीं होगा;और सिर्फ रास्तों की मूल सूची हो। केवल पहले ही असंभव ग्लोब को स्वीकार किया जाएगा, अन्य सभी को एक ही विशिष्ट शक्ति के रूप में देखा जाएगा और फिर से शुरू किया जाएगा। और यहां तक ​​कि पहले वाले को वास्तव में विस्तार नहीं मिलेगा क्योंकि सभी विस्तार अभी भी असंभव हैं और जब उन्हें माना जाता है, तो वे छंट जाएंगे। आदि से प्रणाम किया in*जाएगा i*

उपरोक्त बहुत आक्रामक छंटाई की ओर जाता है और इसलिए कार्यक्रम बहुत कम समय में जटिल मामलों को संभालने में सक्षम है। हालांकि एक बड़ी अक्षमता यह है कि यह उम्मीदवार को सभी संभावित पात्रों के साथ उपसर्ग करता है, न कि केवल ;अलग-अलग स्ट्रिंग के लक्ष्य पथ भाग में एक से पहले वाले । सभी जोड़े गए पात्र जो किसी के सामने नहीं ;हैं, कोई समस्या नहीं है क्योंकि वे एक असंभव ग्लोब को जन्म देते हैं, जिसे माना जाता है, लेकिन यह अभी भी ;अन्य रास्तों से पहले ही पात्रों को छोड़ देता है । तो अंत में प्रोग्राम भी ग्लब्स बनाता है जो दिए गए रास्तों के किसी भी संयोजन से मेल खा सकेगा। इसका कोई विचार नहीं है कि इसे पहले रास्ते पर केंद्रित किया जाना चाहिए।

अब समस्या के समाधान पर विचार करें। दिए गए उदाहरण में */*er/t। यह निम्नलिखित विशिष्ट स्ट्रिंग देता है:

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

मैं ;पहली स्थिति में होने से एक समाधान को पहचानता हूं (इसलिए यह पहले पथ से मेल खाता है) और ;किसी अन्य पथ के प्रारंभ में नहीं है (इसलिए अन्य मेल नहीं खाते)

एल्गोरिथ्म के साथ समझाया अब मैं वास्तविक कार्यक्रम के लिए मिलता है:

अभ्यर्थी ग्लोब एरे में होगा, @aजिसे मैं वैरिएबल का उपयोग करके लूप करता हूं $aजिसमें वर्तमान में विचाराधीन ग्लोब है। इसके बजाय *ग्लोब में मैं फिर भी उपयोग करेगा \w*तो $aवास्तव में एक ग्लोब के बजाय एक regex है। मैं पाश के लिए पर्ल की एक अजीबता का दुरुपयोग करने जा रहा हूं कि आप तत्वों को लूप के दौरान सरणी में जोड़ सकते हैं जबकि लूप चल रहा है और ये नए तत्व लूप में उठाए जाएंगे। चूंकि लंबाई वाले n+1ग्लब्स को बनाते समय सभी लंबाई के 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

//पर्ल में है 'defined or। यह एक छोटी सर्कुलेटिंग की तरह है orजहां दूसरे तर्क का मूल्यांकन किया जाता है यदि पहला एक है undef। और इसे +=कुछ अन्य भाषाओं की तरह ही असाइनमेंट के साथ जोड़ा जा सकता है । तो अगर वे कुंजी $_हैश में %seenहै undef(जो है आप जब एक गैर-मौजूद तत्व तक पहुँचने क्या मिलता है) उसके बाद ही अभिव्यक्ति निष्पादित और कुंजी पर मान के रूप में निर्दिष्ट $_। इसलिए अगर मैं सुनिश्चित expressionकरता हूं undefकि मूल रूप से "अभिव्यक्ति का मूल्यांकन न करें और केवल अगर यह पहली बार है जब हम उस विशिष्ट विशिष्ट स्ट्रिंग को देखते हैं" तो वापस नहीं आता है। और क्योंकि $_इसमें शामिल होने की गारंटी दी जाती है, \nयह वास्तव में सुरक्षित है कि पर्ल ग्लोबल हैश का दुरुपयोग करने के लिए अलग-अलग तारों को स्टोर करें, इसलिए $$_इसके बजाय$seen{$_}

के लिए expressionमैं उपयोग:

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

मूल रूप से "विशिष्ट स्ट्रिंग में हर वर्ण (न्यूलाइन को छोड़कर) के लिए और *इसे वर्तमान ग्लोब के लिए भी प्रीपेंड करें और उम्मीदवार ग्लब्स की सरणी पर पुश करें"। Execpt मैं उपयोग \w*के लिए *एक वैध regex प्राप्त करने के लिए (मैं इस्तेमाल कर सकते हैं ''के बजाय ""एक बैकस्लैश से छुटकारा पाने के, लेकिन फिर मैं कमांड लाइन से मेरी कोड नहीं चला सकता है)। ध्यान दें कि यह भी उठाता है ;और उन्हें उम्मीदवार ग्लब्स में जोड़ता है लेकिन जब बाद में उन्हें बहाल करने के लिए परीक्षण किया जाता है $_जिसमें ऐसा नहीं है ;जो फिर से एक असंभव ग्लोब होगा और प्रून हो जाएगा।

/^;/>/\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;/यदि समाधान अभी तक नहीं मिला है, तो खाली स्ट्रिंग के बराबर मूल्य है, इसलिए यह खाली प्रतिस्थापन स्ट्रिंग के रूप में कार्य करेगा और $_पुनर्स्थापित हो जाएगा


मुझे TIO पर एक त्रुटि मिलती है लेकिन यह स्थानीय स्तर पर काम करती है। क्या आप जानते हैं कि ऐसा क्यों है?
पावेल

1
@Pavel -Eनवीनतम भाषा स्तर को सक्रिय करता है। 5.10.0उपयोग करने में सक्षम होने के लिए आपको कम से कम पर्ल की आवश्यकता होती है say। इसलिए use 5.10.0;हेडर सेक्शन में रखें और यह काम करेगा। भाषा के स्तर की गणना को किसी भी तरह से मुक्त करने के विकल्प, भले ही आप इसका उपयोग न कर सकें -E। वास्तव में आजकल सभी विकल्प मुफ्त में गिने जाते हैं (इसलिए मुझे भी गिनती करने की आवश्यकता नहीं है n0), लेकिन मैं समझता हूं कि पर्ल के लिए बहुत ही उदार है
टन इंजील

2
त्रुटि के साथ बाहर निकलना ठीक है , इसलिए आपका 1/समाधान मान्य है! मुझे यह भी याद रखना चाहिए ...
डोम हेस्टिंग्स

7

जावा 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);}

क्या गड़बड़ है .. यह निश्चित रूप से जावा में एक आसान चुनौती नहीं है। निश्चित रूप से एक दो सौ बाइट्स द्वारा गोल्फ हो सकता है, लेकिन मुझे खुशी है कि अब यह अंततः काम कर रहा है। कहा था। :)
-5 बाइट्स @ceilingcat की बदौलत
-23 बाइट्स जावा 8 से जावा 10 पर स्विच करना

फ़ाइल-पथों के स्ट्रिंग-सरणी के रूप में इनपुट (अलग-अलग आइटम के रूप में निर्देशिकाओं के साथ, और सभी आइटम जिसमें एक अग्रणी होता है /), और इनपुट फ़ाइल-पथ के साथ स्ट्रिंग करने के लिए।

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं। ( ialsohavealongname/ के साथ परीक्षण के मामले ihavealongnameaswellलंबाई में थोड़े कम होते हैं और 60+ सेकंड के बाद समय समाप्त होने के बजाय टीआईओ पर 5-10 सेकंड में काम करने के लिए s.add(x.replaceAll("~+","\\*"));प्रतिस्थापित किया गया है {s.remove(x);s.add(x.replaceAll("~+","\\*"));}।)

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इनपुट फ़ाइल-पथ के रूप में लेते हैं ।

1) मैं फ़ाइल-पथ इनपुट को विभाजित करके शुरू करता हूं /, और इन अलग-अलग शब्दों के सभी फ़ाइल-ग्रिपिंग उत्पन्न करता हूं :

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) फिर मैं ऊपर इस सूची की वस्तुओं पर लूप करता हूं और मान्य करता हूं यदि यह केवल फ़ाइल-पथ के इनपुट सरणी में एक एकल फ़ाइल-पथ से मेल खाती है। (मैं दो चीजों की जांच करके ऐसा करता हूं: क्या स्लैश की मात्रा समान है, और क्या यह रेगेक्स से मेल खाता है जहां *इसे बदल दिया गया है .*।)
यदि यह करता है: (पहले) को सबसे छोटा रखें, जिसे हम अंत में वापस करते हैं।


क्या है >>>? मुझे पता >>है कि बिटकॉइन राइट शिफ्ट है।
पावेल

2
@ पॉवल पॉजिटिव पूर्णांकों के लिए, >>>जैसे ही कार्य करता है >>। लेकिन नकारात्मक पूर्णांकों के लिए यह समता बिट को 0 में बदल देता है (आप कुछ उदाहरण यहां " >> vs >>>> " ) देख सकते हैं । -1>>>1का एक छोटा संस्करण है Integer.MAX_VALUE(और 1<<31होगा Integer.MIN_VALUE)।
केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.