प्रदर्शन के लिए बुद्धिमान पथ छंटनी/इलिप्सिस

Question

मैं अलग-अलग तत्वों पर ध्यान केंद्रित करने वाले पथों के एक सेट के लिए एक मौजूदा पथ ट्रंकेशन एल्गोरिदम (जैसा कि Win32 स्थैतिक नियंत्रण SS_PATHELLIPSIS के साथ करता है) के समान है।

उदाहरण के लिए

, मेरे पथ इस तरह कर रहे हैं:

Unit with X/Test 3V/ 
Unit with X/Test 4V/ 
Unit with X/Test 5V/ 
Unit without X/Test 3V/ 
Unit without X/Test 6V/ 
Unit without X/2nd Test 6V/ 

जब पर्याप्त नहीं प्रदर्शन स्थान उपलब्ध है, वे कुछ करने के लिए इस तरह छोटा कर दिया जाना चाहिए:

...with X/...3V/ 
...with X/...4V/ 
...with X/...5V/ 
...without X/...3V/ 
...without X/...6V/ 
...without X/2nd ...6V/ 

(यह मानते हुए एक अंडाकार कि आम तौर पर तीन अक्षरों से छोटा होता है)।

यह सिर्फ एक नहीं बल्कि साधारण, आदर्श मामले का एक उदाहरण है (उदाहरण के लिए वे सब अलग-अलग लंबाई में पहुंचते हैं अब, और मैं एक अच्छा सुझाव बनाने के लिए कैसे पता नहीं होता है जब एक पथ "thingie/लांग टेस्ट/"पूल में जोड़ा गया है)।

पथ तत्वों की कोई संरचना नहीं है, उन्हें उपयोगकर्ता द्वारा असाइन किया गया है, लेकिन अक्सर वस्तुओं के समान खंड होंगे। इसे आनुपातिक फोंट के लिए काम करना चाहिए, इसलिए एल्गोरिदम को एक उपाय कार्य करना चाहिए (और इसे भारी रूप से कॉल नहीं करना चाहिए) या एक सुझाव सूची उत्पन्न करना चाहिए।

डेटा-वार, एक सामान्य उपयोग मामले में 2..4 पथ खंड प्रति सेग 20 तत्व प्रति सेगमेंट होंगे।

मैं उस दिशा में पिछले प्रयासों की तलाश में हूं, और यदि यह कोड या निर्भरताओं की समझदार मात्रा के बारे में सुलभ है।

Answer 1

मुझे लगता है कि आप मुख्य रूप से पदानुक्रम के समान स्तर से निकाले गए फ़ोल्डर नामों के सेट से निपटने के तरीके के बारे में पूछ रहे हैं, क्योंकि पंक्तियों और पथ विभाजकों द्वारा विभाजित और पदानुक्रम गहराई से एकत्रित करना सरल है।

आपकी समस्या मुझे longest common substring problem का एक बहुत याद दिलाता है, मतभेद उस के साथ:

1. आप कई सबस्ट्रिंग में रुचि रखते हैं, न सिर्फ एक।
2. आप ऑर्डर के बारे में परवाह करते हैं।

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

2 की न्यूनतम सबस्ट्रिंग लंबाई लागू करने से आपके प्रश्न में उल्लिखित परिणाम के समान परिणाम मिल जाएगा।

यह ऐसा प्रतीत होता है कुछ एल्गोरिथ्म को संवारता (उदाहरण के लिए, यह सुनिश्चित एक निश्चित सबस्ट्रिंग सभी स्ट्रिंग्स में पहली है), और फिर आप अपने पूरे सेट पर यह आह्वान करने के लिए की जरूरत की आवश्यकता है ... मुझे आशा है कि यह कम से कम कर देता है आप एक संभावित दिशा है।

Answer 2

ठीक है, "प्राकृतिक संख्या" ऑर्डरिंग हिस्सा वास्तव में आसान है, बस सभी संख्याओं को स्वरूपित संख्या के साथ प्रतिस्थापित करें जहां पर्याप्त प्रमुख शून्य हैं, उदाहरण के लिए। Test 9V ->Test 000009V और Test 12B ->Test 000012B। ये अब मानक तरीकों से क्रमबद्ध हैं।

वास्तविक ellipsisizing के लिए।जब तक कि यह वास्तव में एक बड़ी प्रणाली नहीं है, मैं केवल मैन्युअल ellipsisizing "सूची" (regexes, लचीलापन और दर्द के लिए) जोड़ना होगा जो कुछ शब्दों को अंडाकारों में बदल देगा। इसके लिए लगातार काम की आवश्यकता होती है, लेकिन एल्गोरिदम के साथ आने से आपका समय भी खा जाता है; कोने के मामलों के असंख्य हैं।

मैं शायद "फ्लडफिल" दृष्टिकोण का प्रयास करूंगा। निर्देशिका के पहले स्तर को व्यवस्थित करें क्योंकि आप बिटमैप करेंगे, प्रत्येक अक्षर एक पिक्सेल है। निर्देशिकाओं के नाम पर सभी पात्रों पर पुनरावृत्त करें। उन सभी के साथ, इस चरित्र को "पेंट" करें, फिर अगले स्ट्रिंग से अगले चरित्र को "पेंट करें" जैसे कि यह इस पिछले चरित्र (और इतने पर आदि) का पालन करता है। फिर आपको ढूंढने वाली सबसे लंबी पेंट वाली स्ट्रिंग का चयन करें।

उदाहरण (यदि * उपसर्ग के साथ, यह चित्रित है)

Foo 
BarFoo 

*Foo 
Bar*Foo 

*F*oo 
Bar*F*oo 

... 

ध्यान दें कि:

*ofoo 
b*oo 

*o*foo 
b*oo 
.. painting of first 'o' stops since there are no continuing characters. 

of*oo 
b*oo 
... 

और फिर आप के लिए करने के लिए दूसरा मिल 'ओ' और यह की सबस्ट्रिंग मिलेगा कम से कम 2. तो आपको सबसे संभावित चरित्र उदाहरणों को फिर से शुरू करना होगा (एक अनुकूलन प्रत्येक स्ट्रिंग में स्थिति लंबाई-एन पर रोकना है, जहां n सबसे लंबे समय तक पाया जाने वाला सामान्य सबस्ट्रिंग है। लेकिन फिर एक और समस्या है (यहां "Beta Beta" के साथ)

  | <- visibility cutout 
Alfa Beta Gamma Delta 1 
Alfa Beta Gamma Delta 2 
Alfa Beta Beta 1 
Alfa Beta Beta 2 
Beta Beta 1 
Beta Beta 2 
Beta Beta 3 
Beta Beta 4 

आप क्या करना चाहते हैं? कट Alfa Beta Gamma Delta या Alfa Beta या Beta Beta या Beta?

यह थोड़ा जुआ है, लेकिन मनोरंजन हो सकता है :)।