मूल स्ट्रिंग को खोजें, बीच में दोहराव के बिना पुनरावृत्ति के बिना

Question

कभी-कभी ऐसा होता है कि एक वाक्य लिखते समय, मैं विचलित हो जाता हूं और मैं एक ही जोड़े को दो बार दो- दो शब्दों के दो बार उत्तराधिकार में टाइप करता हूं ।

यह सुनिश्चित करने के लिए कि अन्य लोग इससे परेशान नहीं हैं, आपका कार्य एक प्रोग्राम लिखना है जो इस समस्या को हल करता है!

कार्य

इनपुट स्ट्रिंग को देखते हुए (यदि यह आपकी भाषा के लिए मायने रखता है, तो आप मान सकते हैं कि ASCII- केवल इनपुट जिसमें लाइनफ़ीड नहीं है।) str, जिसमें कहीं न कहीं इसके बीच में एक विकल्प है जो तत्काल उत्तराधिकार में दो बार होता है, स्ट्रिंग को इस के एक उदाहरण के साथ लौटाएं। विकल्प निकाला गया।

कई संभावनाओं के मामले में, संभवतया सबसे छोटा उत्तर लौटाएं (यानी, सबसे लंबे समय तक दोहराए जाने वाले प्रतिस्थापन को चुनें और उस एक को हटा दें)।

कई के मामले में, समान रूप से लंबे समय तक लगातार दोहराए जाने वाले सब्सट्रिंग, पहले को हटा दें (अर्थात, सामने से पीछे की ओर स्ट्रिंग के माध्यम से पढ़ने पर पहले वाला)।

आप यह मान सकते हैं कि इनपुट सही है (अर्थात हमेशा एक लगातार दोहराए जाने वाले प्रतिस्थापन), जो इसे नीचे गोल्फ में मदद कर सकता है।

---

उदाहरण

1. इनपुट: hello hello world-> आउटपुट: hello world।
2. इनपुट: foofoo-> आउटपुट: foo। (इसलिए: हाँ, स्ट्रिंग में केवल दो बार दोहराए जाने वाले भाग शामिल हो सकते हैं)।
3. इनपुट: aaaaa-> आउटपुट:, aaaके रूप में सबसे लंबे समय तक लगातार प्रतिस्थापन यहाँ है aa।
4. इनपुट: Slartibartfast-> यह एक वैध इनपुट नहीं है, क्योंकि इसमें लगातार दोहराए जाने वाले सबस्ट्रिंग नहीं हैं, इसलिए आपको इस मामले को संभालने की आवश्यकता नहीं है।
5. इनपुट: the few the bar-> यह एक और अमान्य इनपुट है, क्योंकि दोहराने वाले हिस्से को तुरंत मूल भाग का पालन करना चाहिए। इस मामले में, theऔर theबीच में कुछ और द्वारा अलग किया जाता है, इसलिए यह इनपुट अमान्य है।
6. इनपुट: ababcbc-> आउटपुट: abcbc। दो संभव सबसे लंबे समय तक लगातार दोहराए जाने वाले पदार्थ हैं abऔर bc। जैसा कि abपहले स्ट्रिंग में सामने आया है, यह सही उत्तर है।
7. इनपुट: Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo। आउटपुट: Buffalo buffalo buffalo buffalo Buffalo buffalo। (प्रदत्त प्रतिस्थापन केस-संवेदी होना चाहिए)।
8. इनपुट: Sometimes it happens that while typing a sentence, I am distracted and I end up typing the same couple of words twice couple of words twice in succession.-> आउटपुट: Sometimes it happens that while typing a sentence, I am distracted and I end up typing the same couple of words twice in succession.। केवल सबसे लंबे समय तक लगातार दोहराए जाने वाले प्रतिस्थापन को हटा दिया जाता है।

---

आपका कोड जितना संभव हो उतना छोटा होना चाहिए, क्योंकि यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है। सौभाग्य!

Comments

@ मैनटवर्क जब पहला वाक्य लेते हैं, तो वह Sometimes it happens that while typing a sentence, I am distracted and I end up typing the same couple of words twice couple of words twice in succession.इनपुट के रूप में होता है, आउटपुट होना चाहिए Sometimes it happens that while typing a sentence, I am distracted and I end up typing the same couple of words twice in succession.। केवल सबसे लंबे समय तक पाया जाने वाला दोहराव हटा दिया जाता है।

— Qqwy

मैं एक परीक्षण जोड़ने का सुझाव देता हूं जिसमें दो संभव प्रतिस्थापन हैं, जहां दूसरा पहले की तुलना में लंबा है। मुझे लगता है सबसे जवाब पारित नहीं होगा कि एक :)

— aross

@ सकल परीक्षण मामला 8 वास्तव में है :)

— Qqwy

जब तक मुझे और मेरे परीक्षण कोड को गलत नहीं किया जाता है, तब तक केवल एक दोहराया स्ट्रिंग है।

— aross

@ सकल एक डबल pमें हैhappens

— Qqwy

Answer 1

पर्ल 6 , 40 बाइट्स

{.subst: m:ex/(.*))>$0/.max(*.chars),''}

कोशिश करो

{
  .subst:             # substitute


    m                 # match
    :exhaustive
    /
      ( .* )          # any number of chars

      )>              # don't include the following in what is returned

      $0              # the first match again
    /.max( *.chars ), # find the first longest submatch


    ''                # substitute it with nothing
}

Answer 2

रेटिना , 35 33 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

(?=(.+)(\1.*))
$2¶$`
O$#`
$.&
G1`

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

व्याख्या

चूंकि रेगेक्स इंजन बाएं से दाएं की ओर मैच देखता है, इसलिए स्थिति की परवाह किए बिना सबसे लंबे मैच का पता लगाना तुच्छ नहीं है। यह .NET के संतुलन समूहों के साथ किया जा सकता है, लेकिन परिणाम अप्रिय रूप से लंबा है:

1`((.)+)\1(?<=(?!.*((?>(?<-2>.)+).+)\3)^.*)
$1

इसलिए मुझे लगा कि मैं कुछ अन्य रेटिना सुविधाओं का उपयोग करके इससे बचने की कोशिश करूंगा।

(?=(.+)(\1.*))
$2¶$`

हम अनिवार्य रूप से सभी संभव प्रतिस्थापन, प्रत्येक पंक्ति पर एक को लागू करने से शुरू करते हैं। ऐसा करने के लिए, हम ओवरलैपिंग मैचों की अनुमति देने के लिए, एक मैच के सामने स्थिति का मिलान करते हैं (मैच के बजाय)। यह असली रेगेक्स को एक लुकहेड में डालकर किया जाता है। वह लुकहेड तब शेष को कैप्चर करता है जिसे हम समूह 2 में हटाना चाहते हैं डुप्लिकेट को छोड़कर। हम ग्रुप 2 लिखते हैं (डुप्लिकेट को हटाते हुए), एक लाइनफीड, और फिर मैच तक पूरा इनपुट, जो हमें मूल रूप से एक नई लाइन देता है। प्रतिस्थापित किया जाए।

अंत में, हमारे पास प्रत्येक मैच के लिए एक पंक्ति होगी, इसी डुप्लिकेट को हटा दिया जाएगा। अंत में बिना किसी प्रतिस्थापन के पूर्ण इनपुट फिर से होगा।

अब जब हमारे पास सभी संभावित प्रतिस्थापन हैं, तो हम सबसे छोटा परिणाम चाहते हैं (जो सबसे लंबे समय तक हटाए गए पुनरावृत्ति से मेल खाता है)।

O$#`
$.&

इसलिए हम पहले लाइनों को लंबाई के आधार पर क्रमबद्ध करते हैं।

G1`

और फिर हम केवल पहली पंक्ति रखते हैं।

Comments

वाह, यह प्रतिस्थापन तकनीक वास्तव में चतुर है!

— सिंह

Answer 3

जेली , 22 19 बाइट्स

डेनिस के लिए -2 बाइट्स

ẋ2³wȧ+¥J
ẆÇ€LÐṀḢṬœp

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

पूर्ण कार्यक्रम (एक बग पाया गया है जिसमें ÐṀरंगों पर सही शुद्धता के साथ काम नहीं किया गया है , जो जल्द ही तय हो जाएगा; हालांकि मुझे यकीन नहीं है कि यह छोटे कोड के लिए बना सकता है)।

कैसे?

इनपुट के सबसे लंबे स्लाइस को पहले से ढूँढता है जैसे कि इनपुट में एक पुनरावृत्ति मौजूद है और इसे इनपुट से हटा देता है।

ẋ2³wȧ+¥J - Link 1, removal indices for given slice if valid, else 0: slice, x
ẋ2       - repeat x twice, say y
  ³      - program input: s
   w     - index of first occurrence of y in s (1-based) or 0, say i
       J - range(length(x)): [1,2,3,...,length(x)]
      ¥  - last two links as a dyad
    ȧ    -     and (non-vectorising)
     +   -     addition: [1+i,2+i,3+i,...,length(x)+i] or 0
         - note: no need to decrement these since the last index will be the 1st index
         - of the repetition (thanks to Dennis for spotting that!)

ẆÇ€LÐṀḢṬœp - Main link: string, s
Ẇ          - all sublists of s (order is short to long, left to right, e.g. a,b,c,ab,bc,abc)
 Ç€        - call the last link (1) as a monad for €ach
    ÐṀ     - filter by maximal
   L       -     length
      Ḣ    - head: get the first (and hence left-most) one
       Ṭ   - untruth: make a list with 1s at the indexes given and 0s elsewhere
        œp - partition s at truthy indexes of that, throwing away the borders
           - implicit print

Answer 4

जावास्क्रिप्ट (ईएस 6), 81 74 बाइट्स

f=
s=>s.replace(/(?=(.+)\1)/g,(_,m)=>r=m[r.length]?m:r,r='')&&s.replace(r,'')

<input oninput=o.textContent=f(this.value)><pre id=o>

संपादित करें: @ Arnauld की m[r.length]चाल चोरी करके 7 बाइट्स सहेजे गए ।

Answer 5

पॉवरशेल , 87 बाइट्स

param($s)([regex](([regex]'(.+)\1'|% *hes $s|sort L*)[-1]|% Gr*|% V*)[1])|% Re* $s '' 1

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले)

व्याख्या

मूल रूप से अंदर से शुरू, हम रेगेक्स के Matchesसाथ चलते हैं (.+)\1, निर्दिष्ट स्ट्रिंग के लिए सभी मैच ऑब्जेक्ट वापस करने के लिए। रेगेक्स पात्रों के किसी भी क्रम से मेल खाता है जो उसके बाद है।

फिर परिणामी मिलान वस्तुओं को sortउनकी Lengthसंपत्ति (वाइल्डकार्ड से छोटा) द्वारा क्रमबद्ध किया जाना है । यह लंबाई, आरोही द्वारा क्रमबद्ध मैचों की एक सरणी में परिणाम करता है, इसलिए [-1]अंतिम तत्व (सबसे लंबा) प्राप्त करने के लिए सूचकांक । उस मैच का मान मैच है, हालांकि समूह नहीं, इसलिए इसमें पुनरावृत्ति शामिल है, इसलिए हम सबसे बड़ी दोहराई जाने वाली स्ट्रिंग प्राप्त करने के लिए समूह ऑब्जेक्ट ( |% Gr*) और फिर उस ( |% V*) का मान प्राप्त करते हैं। बात समूह वस्तु वास्तव में एक सरणी है समूह 0 हमेशा मैच है क्योंकि है, लेकिन मैं वास्तविक समूह (1) चाहते हैं, इसलिए परिणामस्वरूप मूल्य वास्तव में मूल्य है रों , इसलिए दूसरा तत्व प्राप्त करने के लिए का अनुक्रमण [1]। यह मान regex ऑब्जेक्ट के लिए ही डाला गया है और फिरReplaceविधि को मूल स्ट्रिंग के खिलाफ कहा जाता है, कुछ भी नहीं के साथ प्रतिस्थापित किया जाता है, और केवल पहले मैच को बदल दिया जाता है ( |% Re* $s '' 1)।

Answer 6

हास्केल , 101 बाइट्स

मुख्य कार्य है f, यह लेता है और लौटता है String।

l=length
a=splitAt
f s|i<-[0..l s-1]=[p++t|n<-i,(p,(r,t))<-fmap(a$l s-n).(`a`s)<$>i,r==take(l r)t]!!0

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

जब मैं इस शुरू कर दिया, मैं आयातित Data.Listऔर इस्तेमाल किया maximum, tails, initsऔर isPrefixOf। किसी तरह जो इस में बदल गया। लेकिन मैं अभी भी केवल 11 बाइट्स दाढ़ी बनाने में कामयाब रहा ...

टिप्पणियाँ

• splitAt/ aएक दिए गए सूचकांक में एक स्ट्रिंग को विभाजित करता है।
• s इनपुट स्ट्रिंग है।
• iसंख्याओं की सूची है [0 .. length s - 1], बहुत बड़े सूचकांक दिए जाने पर -1उस splitAtविभाजन के चारों ओर काम करना है ।
• nहै length sशून्य से वर्तमान लंबाई लक्ष्य दोहराया भाग के लिए, यह उस तरह से चुना है हम सूची वाक्य रचना को कम वर्बोज़ नंबर दो सूचियों और / या उपयोग करने के लिए की जरूरत नहीं है तो।
• p, rऔर , इरादा दोहराया भाग के साथ, tका एक मार्ग विभाजन है । वहाँ का उपयोग करता है एक मध्यवर्ती विभाजन के लिए एक चर से बचने के लिए।srfmap(,) String Functor
• !!0 मैचों की सूची का पहला तत्व चुनता है।

Answer 7

जेली , 23 21 बाइट्स

ṚẆUẋ€2ẇÐf¹ṪðLHḶ+w@Ṭœp

उनके Ṭœpविचार के लिए @JonathanAllan का धन्यवाद जिसने 2 बाइट्स बचाए।

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

Answer 8

गणितज्ञ, 63 60 59 बाइट्स

^{मार्टिन एंडर के कारण 4 बाइट बच गए ।}

#&@@StringReplaceList[#,a__~~a__->a]~SortBy~{StringLength}&

अनाम फ़ंक्शन। एक स्ट्रिंग को इनपुट के रूप में लेता है और एक स्ट्रिंग को आउटपुट के रूप में देता है।

Comments

यह उदाहरण 6 पर काम करने के लिए प्रतीत नहीं होता है - ~SortBy~StringLengthयदि उनकी लंबाई समान है तो वर्णानुक्रम में तार ...

— पेड़ नहीं

@ LegionMammal978 एक स्थिर क्रम पाने के लिए सूची में छोटा फिक्स रखा जाता है SortByऔर लपेटा StringLengthजाता है।

— मार्टिन एंडर

Answer 9

जावास्क्रिप्ट (ईएस 6), 70 बाइट्स

s=>s.replace(s.match(/(.+)(?=\1)/g).reduce((p,c)=>c[p.length]?c:p),'')

परीक्षण के मामलों

let f =

s=>s.replace(s.match(/(.+)(?=\1)/g).reduce((p,c)=>c[p.length]?c:p),'')

console.log(f("hello hello world"))
console.log(f("foofoo"))
console.log(f("aaaaa"))
console.log(f("ababcbc"))
console.log(f("Sometimes it happens that while typing a sentence, I am distracted and I end up typing the same couple of words twice couple of words twice in succession."))

Comments

पर विफल रहता है aaaabaaab, लेकिन का अच्छा उपयोग reduce।

— नील

Answer 10

यह एक टिप्पणी होनी चाहिए, लेकिन मेरे पास टिप्पणी करने के लिए पर्याप्त प्रतिष्ठा नहीं है। मैं सिर्फ @Neil को बताना चाहता हूं कि उसका कोड 77 बाइट्स तक कम किया जा सकता है। आप regex में आगे मुखर का उपयोग करने की जरूरत नहीं है। यहाँ संस्करण घटाया गया है:

s=>s.replace(/(.+)\1/g,(_,m)=>(n=m.length)>l&&(l=n,r=m),l=0)&&s.replace(r,'')

Comments

नमस्कार, और PPCG में आपका स्वागत है! आप इसे अपने स्वयं के जावास्क्रिप्ट उत्तर के रूप में प्रस्तुत कर सकते हैं! यदि आप चाहें, तो मैं आपकी पोस्ट को संपादित कर सकता हूं और आपको दिखा सकता हूं कि यह कैसा दिखना चाहिए।

— NoOneIsHere

ओवरलैपिंग मैचों के मामले से निपटने के लिए मुझे आगे के दावे का उपयोग करने की आवश्यकता है। aababसबसे छोटा उदाहरण है जहां आपका सुझाव विफल हो जाता है।

— नील

Answer 11

सी #, 169 बाइट्स

(s)=>{var x="";for(int i=0;i<s.Length-2;i++){for(int l=1;l<=(s.Length-i)/2;l++){var y=s.Substring(i,l);if(s.Contains(y+y)&l>x.Length)x=y;}}return s.Replace(x+x,x);}

व्याख्या

(s) => {                // Anonymous function declaration    
    var x = "";         // String to store the longest repeating substring found
    for (int i = 0; i < s.Length - 2; i++) {               // Loop through the input string
        for (int l = 1; l <= (s.Length - i) / 2; l++) {    // Loop through all possible substring lengths
            var y = s.Substring(i, l);
            if (s.Contains(y + y) & l > x.Length) x = y;   // Check if the substring repeats and is longer than any previously found
        }
    }
    return s.Replace(x + x, x);    // Perform the replacement
}

यह जानवर-बल दृष्टिकोण है: जब तक हम सबसे लंबे समय तक दोहराए जाने वाले सबस्ट्रिंग को नहीं ढूंढते तब तक हर संभव विकल्प की कोशिश करें। निस्संदेह रेगेक्स अधिक कुशल है, लेकिन रेक्स के साथ सी # में व्यवहार करना काफी क्रियात्मक है।

Comments

PPCG में आपका स्वागत है! सभी उत्तरों को या तो पूर्ण कार्यक्रम या कॉल करने योग्य फ़ंक्शन होने की आवश्यकता है , न कि हार्डकॉपी चर में इनपुट के साथ स्निपेट्स। इसके अलावा, कृपया उस कोड का संस्करण दिखाएं जिसे आपने वास्तव में हटाए गए सभी अनावश्यक व्हाट्सएप के साथ गिना था। आप हमेशा पूरी तरह से गोल्फ वाले के अलावा इंडेंटेशन के साथ अधिक पठनीय संस्करण को शामिल कर सकते हैं।

— मार्टिन एंडर

Answer 12

PHP, 84 82 बाइट्स

नोट: IBM-850 एन्कोडिंग का उपयोग करता है।

for($l=strlen($argn);--$l&&!$r=preg_filter("#(.{0$l})\g-1#",~█╬,$argn,1););echo$r;

इस तरह से चलाएं:

echo 'hello hello world' | php -nR 'for($l=strlen($argn);--$l&&!$r=preg_filter("#(.{0$l})\g-1#",~█╬,$argn,1););echo$r;';echo
> hello world

व्याख्या

for(
  $l=strlen($argn);   # Set $l to input length.
  --$l   &&           # Decrement $l each iteration until it becomes 0.
  !$r=preg_filter(    # Stop looping when preg_filter has a result
                      # (meaning a successful replace).
    "#(.{0$l})\g-1#", # Find any character, $l times (so the longest
                      # match is tried first), repeated twice.
    ~█╬,              # Replace with $1: first capture group, removing the
                      # duplicate.
    $argn,
    1                 # Only replace 1 match.
  );
);
echo$r;               # Print the result of the (only) successful
                      # search/replace, if any.

बदलाव

• सहेजे गए 2 बाइट्स क्योंकि दोहराए गए विकल्प की कोई न्यूनतम लंबाई नहीं है