শেল গ্লোব গল্ফিং


11

এই কাজটি হ'ল গ্লোব সম্প্রসারণের পরে কোনও ফাইলের সবচেয়ে সংক্ষিপ্ত পথ আউটপুট।

শেল গ্লোব্বিং কী? বেশিরভাগ শেলগুলিতে, আপনি *অবস্থানটিতে যে কোনও অক্ষরকে উপস্থাপন করতে আপনি একটি চরিত্রটি ব্যবহার করতে পারেন । উদাহরণস্বরূপ, যদি ডিরেক্টরিতে fooফাইলগুলি থাকে bar bazএবং asdfতারপরে foo/b*প্রসারিত হবে foo/bar foo/baz

এখন, ধরুন যে বর্তমান ডিরেক্টরিটিতে একটি ফাইল বলা আছে যা ihavealongnameঅন্য কোনও কিছুই নয়। আমি যদি এই ফাইলটি উল্লেখ করতে চাই তবে আমি টাইপ করতে পারি *, যা পুরো নামটি টাইপ না করে কেবল সেই একটি ফাইলকেই উপস্থাপন করে।

ডিরেক্টরিতে যদি কোনও ফাইল নামক ফাইল থাকে তবে ialsohavealongnameআমি এটি করতে পারি না *, কারণ এটি দুটি ফাইলই মিলবে will আমি করতে হবে, কমপক্ষে ih*,।

*প্যাটার্ন ফাইল আমি চাই উপরে ডিরেক্টরি মিলে জন্য কাজ করে। যদি কেবল দুটি ডিরেক্টরি থাকে fooএবং barতবে fooকেবল একটি ফাইল থাকে bazএবং barএতে ফাইল থাকে তবে asdfআমি এর foo/bazসাথে মেলাতে পারি */baz। বা আরও সংক্ষেপে */b*,। যদি barখালি ছিল, */*কাজ করবে।

আপনার টাস্ক: "বর্তমান ডিরেক্টরি" এবং একটি একক লক্ষ্য পাথকে উপস্থাপন করে এমন একটি স্ট্রিং অ্যারে দেওয়া হয়েছে, সংক্ষিপ্ততম স্ট্রিং আউটপুট দেয় যা * গুলি প্রসারিত হওয়ার পরে কেবল সেই লক্ষ্য পথে প্রসারিত হয়।

লক্ষ্য পাথটিকে তার নিজস্ব স্ট্রিং হিসাবে, পাথের অ্যারেতে সূচক হিসাবে নেওয়া যেতে পারে, পাথের অ্যারেতে প্রথম আইটেমটি প্রবেশ করানো বা অন্য কোনও সুবিধাজনক উপায়ে হার্ড-কোডিং নয়। অনিশ্চিত হলে মন্তব্যে জিজ্ঞাসা করুন।

লক্ষ্যপথটি "বর্তমান ডিরেক্টরিতে" উপস্থিত থাকার গ্যারান্টিযুক্ত।

আপনি ধরে নিতে পারেন যে সমস্ত পাথগুলিতে কেবলমাত্র বর্ণানুক্রমিক ASCII (এবং /গুলি) থাকে। আপনি যে ইনপুট পাথগুলি শিকড় (শুরু /) বা আত্মীয় (শুরু করবেন না) হিসাবে গ্রহণ করতে পারেন /

যদি একাধিক সমান সংক্ষিপ্ত সম্ভাবনা থাকে তবে তাদের যে কোনও বা সমস্তটি ফিরিয়ে দিন।

এই সবচেয়ে কম বাইট জেতা!

পরীক্ষার কেস , কেভিন ক্রুইজসেনকে ধন্যবাদ ।


4
সুতরাং আমরা অনুমান করতে পারেন ফাইলের নামের খালি জায়গা থাকা না, নতুন লাইন, ব্যাকস্ল্যাশ, *, ?, [ ইত্যাদি? এটি কেবল সবচেয়ে সহজ হতে পারে যদি আপনি কেবল যে ফাইল এবং ডিরেক্টরিটির নাম বর্ণানুক্রমিকভাবে উল্লেখ করেন
টন হসপেল

3
আসল ডিস্ক I / O অংশটি অনেক ভাষায় বিরক্তিকর হবে। উদাহরণস্বরূপ পার্লে আমি কেবল ফাইলের নাম নেব এবং প্রাসঙ্গিক হতে পারে এমন সমস্ত ফাইলের নাম পেতে (যেমন হয়ে ওঠে ) পেতে সমস্ত পাথ উপাদানগুলি প্রতিস্থাপন করব *এবং পার্ল চালাব । এর পরে এটি স্ট্রিং প্রসেসিং চ্যালেঞ্জ হয়ে যায়। এবং এই চ্যালেঞ্জ ইতিমধ্যে যথেষ্ট কঠিন। আমি মনে করি যে এই চ্যালেঞ্জটি "বর্ণানুক্রমিক (এবং ) আপেক্ষিক পাথের একটি তালিকা দেওয়া হিসাবে স্বল্পতম globfoo/bar/baz*/*/*/
গ্লোব

1
@ কেভিন ক্রুজসেন অবশ্যই, এটি একটি মজাদার চ্যালেঞ্জ এবং বেশিরভাগ খাঁটি গল্ফিং ভাষাগুলি দূরে রাখা উচিত আমার মনে হয় আপনার একটি আসল প্রোগ্রামের প্রয়োজন হবে (যদি না আপনি যতটা বিরক্তিকর কাজ করে যা সবচেয়ে সংক্ষিপ্তভাবে আঘাত না করে ততক্ষণ সম্ভব সমস্ত স্ট্রিং তৈরি না করে) আপনার বর্তমান উদাহরণগুলি আপনার কেসগুলি হ্যান্ডেল করা প্রয়োজন সবেই কাভার শুরু করুন। ব্যবহার: এখানে পরাগধানী ক্ষেত্রে a*fনির্বাচন করতে azzfথেকে azzf, azzg, bzzfa*b*cইত্যাদিতে ইচ্ছামত প্রসারিত করুন ..
টন হসপেল

2
টনহোস্পেল আমি নিশ্চিত আপনি এখন ইনপুট হিসাবে পাথের অ্যারে নেন।
পাভেল

4
@ ওয়েইজুনঝু আমি ইনপুট সম্পর্কে আমার মন পরিবর্তন করেছি। আপনি এখন পথের একটি অ্যারে নিতে পারেন।
পাভেল

উত্তর:


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 দ্বারা এবং *দৈর্ঘ্য প্রতিটি উল্লিখিত glob সামনে n। তাই যেমন দৈর্ঘ্য 3 উল্লিখিত glob *i*দৈর্ঘ্য 4 globs অবদান রাখবে f*i*, o*i*, o*i*, /*i*, b*i*... s*i*, t*i*এবং পরিশেষে **i*। লক্ষ্য করুন যে ইনপুট পাথগুলির তালিকা থেকে প্রতিটি অক্ষর একাধিকবার প্রদর্শিত হলেও বা কিছুই বোঝা যায় না, যদিও এটি কখনও মিলছে না এমন দিকে পরিচালিত করে।

নির্বুদ্ধিভাবে এটি করার ফলে একটি মিশ্র বিস্ফোরণ ঘটবে। এই কারণেই প্রতিটি প্রার্থী গ্লোব কতটা কার্যকর তার জন্য মূল্যায়ন করে যদি গ্লোব সম্পূর্ণ গ্লোব শেষে ব্যবহার করা হত তবে কোন পন্থাগুলির সাথে এটি মিলতে পারে তা নির্ধারণ করে। আমি ;যেখানে প্রতিযোগিতা সম্ভব সেখানে প্রতিটি জায়গায় একটি প্রবেশ করে এটি করি do উদাহরণস্বরূপ গ্লোব 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যা বর্তমানে বিবেচনাধীন গ্লোব ধারণ করে। বদলে *উল্লিখিত glob আমি কিন্তু ব্যবহার করবে \w*, যাতে $aআসলে একটি উল্লিখিত glob পরিবর্তে একটি Regex হয়। আমি লুপটির জন্য পার্লের একটি অদ্ভুততার অপব্যবহার করছি যা আপনি লুপটি চলার সময় অ্যারেগুলিকে সংযোজন করতে পারবেন এবং এই নতুন উপাদানগুলি লুপটিতে উঠবে। যেহেতু দৈর্ঘ্যের n+1গ্লোব তৈরি করার সময় সমস্ত দৈর্ঘ্যের nগ্লোবগুলি ইতিমধ্যে অ্যারেতে থাকে@a এটি প্রথম প্রস্থে।

দরুন -n0বিকল্প (পুরো ইনপুট উপর অন্তর্নিহিত লুপ) পথগুলিতে তালিকায় রয়েছে $_প্রতিটি পাথ দিয়ে এক বিশাল স্ট্রিং একটি newline সঙ্গে সমাপ্ত

@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*"

মূলত "প্রতিটি চরিত্রের জন্য (নিউলাইন ব্যতীত) পৃথক পৃথক স্ট্রিং এ এবং *এটি বর্তমান গ্লোবে প্রিপেন্ড করে এবং এটি প্রার্থী গ্লোবগুলির অ্যারেতে চাপ দিন"। আমি বৈধ রেইগেক্স পাওয়ার \w*জন্য ব্যবহার করি *(আমি একটি ব্যাকস্ল্যাশ থেকে মুক্তি পাওয়ার ''পরিবর্তে ব্যবহার ""করতে পারি তবে কমান্ড লাইন থেকে আমার কোডটি চালাতে পারিনি)। লক্ষ্য করুন যে এটিও বাছাই করে ;এবং সেগুলি পরীক্ষার্থীদের গ্লোবগুলিতে যুক্ত করে তবে পরে তাদের পুনরুদ্ধারে পরীক্ষা করার পরে $_যা ;আবার নেই এটি একটি অসম্ভব গ্লোব হবে এবং ছাঁটাই হবে।

/^;/>/\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;/কোনও সমাধান এখনও পাওয়া যায় নি এমন ক্ষেত্রে শূন্য স্ট্রিংয়ের সমান মান রয়েছে, সুতরাং এটি খালি প্রতিস্থাপনের স্ট্রিং হিসাবে কাজ করবে এবং $_পুনরুদ্ধার হবে


টিআইওতে আমি একটি ত্রুটি পেয়েছি তবে এটি স্থানীয়ভাবে কাজ করে। কেন যে হয় আপনি কি জানেন?
পাভেল

1
@ পাভেল -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 বাইট @ সিলিংক্যাট ধন্যবাদ ।
-23 বাইট জাভা 8 থেকে জাভা 10 এ স্যুইচ করছে

ফাইল-পাথের স্ট্রিং-অ্যারে হিসাবে ইনপুট করুন (পৃথক আইটেম হিসাবে ডিরেক্টরিগুলি এবং একটি শীর্ষস্থানীয় সমস্ত আইটেম সহ /) এবং গ্রপ করার জন্য ইনপুট ফাইল-পাথ সহ একটি স্ট্রিং।

ব্যাখ্যা:

এটি অনলাইনে চেষ্টা করুন। (পরীক্ষার কেসগুলির সাথে ialsohavealongname/ ihavealongnameaswellদৈর্ঘ্যে কিছুটা হ্রাস পেয়েছে এবং I০+ সেকেন্ড পরে সময় নির্ধারণের পরিবর্তে টিআইওতে 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 তে পরিবর্তন করে (আপনি এখানে " >> বনাম >>> " বিভাগে কিছু উদাহরণ দেখতে পারেন )। -1>>>1এর সংক্ষিপ্ত রূপটি Integer.MAX_VALUE(এবং 1<<31হবে Integer.MIN_VALUE)।
কেভিন ক্রুইজসেন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.