प्रिमिंग पुजल्स एंड कॉलफ: कॉन्डेंस ए स्ट्रींग

Question

इस साइट पर कुछ समय बिताने के बाद मैं चीजों का आनंद लेने के लिए आया हूं। यही कारण है कि मैं हाल ही में एक से अधिक बार एक ही वर्ण वाले तार से नाराज हूं। अपनी नौकरी एक समारोह या कार्यक्रम जो लिखना है संघनित निम्नलिखित नियमों के अनुसार एक दिया स्ट्रिंग:

• 0-संक्षेपण के साथ शुरू करें , जो कि उनके बीच 0 अन्य वर्णों के साथ समान वर्णों की पहली (सबसे बाईं ओर) जोड़ी है। यदि ऐसी जोड़ी पाई जाती है, तो दो पात्रों में से एक को हटा दें और एक और 0-संक्षेपण करके एल्गोरिथ्म को पुनरारंभ करें । यदि ऐसी कोई जोड़ी नहीं मिली है, तो अगले चरण पर आगे बढ़ें। उदाहरण:
  programming-C0-> programing
aabbcc-C0-> abbcc
test-C0->test

• फिर 1-संघनन करें , जो कि उनके बीच 1 अन्य वर्ण के साथ समान वर्णों की पहली जोड़ी के लिए देखें। यदि ऐसी जोड़ी पाई जाती है, तो उनमें से एक और उनके बीच के सभी पात्रों को हटा दें और 0-संक्षेपण के साथ पुनः आरंभ करें । यदि ऐसी कोई जोड़ी नहीं मिली है, तो अगले चरण पर आगे बढ़ें। उदाहरण:
  abacac-C1-> acac
java-C1->ja

• 2-संक्षेपण के साथ जारी रखें और इसी तरह मूल संक्षेप की लंबाई n होने के साथ एक संक्षेपण तक, हर बार संक्षेपण के बाद कुछ अक्षरों को हटा दिया जाता है। उदाहरण:
  programing-C2-> praming
abcdafg-C3->afg

परिणामी स्ट्रिंग को संघनित कहा जाता है और प्रत्येक वर्ण में एक बार सबसे अधिक होता है।

---

इनपुट:

मुद्रण योग्य अस्की-पात्रों का एक निचला केस स्ट्रिंग।

आउटपुट:

सघन स्ट्रिंग उपरोक्त नियमों के अनुसार।

उदाहरण:

examples     -> es
programming  -> praming
puzzles      -> puzles
codegolf     -> colf
andromeda    -> a
abcbaccbabcb -> acb
if(x==1):x++ -> if(x+
fnabnfun     -> fun
abcdefae     -> abcde

एल्गोरिथ्म कैसे काम करता है, यह स्पष्ट करने के लिए विस्तृत उदाहरण:

fnabnfun -C0-> fnabnfun -C1-> fnabnfun -C2-> fnfun -C0-> fnfun -C1-> fun -C0-> fun 
 -C1-> fun -C2-> ... -C8-> fun

abcbaccbabcb -C0-> abcbacbabcb -C0-> abcbacbabcb -C1-> abacbabcb -C0-> abacbabcb 
 -C1-> acbabcb -C0-> acbabcb -C1-> acbcb -C0-> acbcb -C1-> acb -C0-> acb 
 -C1-> ... -C12-> acb

आपके दृष्टिकोण को आपके समाधान के ऊपर से एल्गोरिथ्म को लागू करने की आवश्यकता नहीं है और एल्गोरिथ्म सभी अनुमत इनपुट के लिए समान आउटपुट लौटाता है। यह एक कोड-गोल्फ चुनौती है।

---

सहायक सैंडबॉक्स टिप्पणियों के लिए @ लिनुस को धन्यवाद !

Comments

@MartinEnder रिले का परीक्षण मामला अभी भी आवश्यक है, क्योंकि यह केवल एक है मेरा रेटिना समाधान काम नहीं करता है।

— mbomb007

@ mbomb007 आह, मैं देख रहा हूं। अच्छी बात।

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

क्या इनपुट स्ट्रिंग में कभी रिक्त स्थान जैसे गैर-मुद्रण योग्य वर्ण होंगे?

— mbomb007

@ mbomb007 नहीं, मुद्रण योग्य अस्सी वर्णों को मानने के लिए केवल ठीक है।

— लकोनी

@ mbomb007 हालाँकि जहाँ तक मुझे पता है, एक जगह को प्रिंट करने योग्य अस्की चरित्र माना जाता है, जैसे यहाँ ।

— लाकोनी

Answer 1

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

f=
(s,n=0,m=s.match(`(.).{${n}}\\1`))=>s[n]?m?f(s.replace(...m)):f(s,n+1):s
;

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

Comments

बहुत अच्छा, जो मैंने सोचा था उससे कम।

— 23

Answer 2

पर्ल, 38 31 30 29 बाइट्स

यह गैर-गोल्फ भाषाओं को बहुत पीछे छोड़ देना चाहिए ...

-1 रिले के लिए $-[0]धन्यवाद

-1 दादा@{-} को धन्यवाद

के लिए +1 शामिल है -p

STDIN पर इनपुट दें

condense.pl:

#!/usr/bin/perl -p
s/(.)\K.{@{-}}\1// while/./g

यह 27 बाइट संस्करण काम करना चाहिए, लेकिन यह क्योंकि पर्ल लगाना नहीं है नहीं है @-एक regex में (देखें /programming/39521060/why-are-etc-not-interpolated-in-strings )

#!/usr/bin/perl -p
s/(.)\K.{@-}\1// while/./g

Comments

@{\@-}भाग कैसे काम करता है ? मैंने सोचा @-था कि प्रत्येक मैच के अनुक्रमित हैं, इसलिए यह हर पुनरावृत्ति पर "गणना" कैसे करता है। इसके अलावा, अगर आप @{\@-}प्रत्येक प्रतिस्थापन से पहले और बाद में प्रिंट करते हैं तो यह केवल 1 या 2 प्रिंट करता है

— रिले

@ रिले /./gस्ट्रिंग में हर बार 1 की प्रगति करता है, जब स्ट्रिंग बदल जाता है, तब इसे 0. पर रीसेट करता है। यदि आप प्रिंट @-करते हैं, /./gलेकिन इससे पहले कि s///आप इसे ऊपर जाते हुए देखेंगे (परीक्षण का उपयोग करें जहां शेष स्ट्रिंग काफी बड़ा है)

— बजे टन हास्पेल

मुद्रण $-[0]मुझे उम्मीद है कि संख्या देता है। रेगेक्स संदर्भ के कारण @{\@-}कार्य करता $-[0]है लेकिन किसी कारण से छपाई के दौरान नहीं? यदि वे समान हैं तो $-[0]बाइट कम है @{\@-}।

— रिले

"@{\@-}"@{\@-}(बिना ") के समान नहीं है ।

— रिले

@ रिले नहीं, लेकिन "@{\@-}"जैसा है वैसा ही है "@-"। और यह भी एक regex प्रतिस्थापन के लिए सच होना चाहिए, लेकिन यह नहीं है। Simularly $-[0]काम करते हैं लेकिन ऐसा नहीं करता चाहिए। पुनश्च: आप किसी भी तरह से स्केलर संदर्भ लागू करते थे @-जब आपने अपना प्रिंट किया था, तो आपको हमेशा 1 या 2 मिला

— टन हास्पेल

Answer 3

सीजेएम , 35 बाइट्स

rL{_,{{(_@_@#I={I)>]sj}*}h]s}fI}j

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

---

rL{                            }j   | run recursion on input
   _,{                      }fI     | for I from 0 to length(input)
      {                 }h]s        | one pass & clean up
       (_@                          | slice and store leading element A
          _@#I={      }*            | if next A is I steps away
                I)>                 | slice off I+1 element
                   ]sj              | clean up & recursion

आप सम्मिलित करके व्यक्तिगत संवेदना देख सकते हैंed

Answer 4

पायथन 2, 117 104 101 बाइट्स

आवश्यक प्रतिस्थापनों को पुन: करें। मैं गतिशील रूप से रेगेक्स का निर्माण करता हूं।

import re
def f(s,i=0):t=re.sub(r"(.)%s\1"%("."*i),r"\1",s);e=s==t;return i>len(t)and t or f(t,i*e+e)

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

Comments

दो वापसी रेखाओं return i>len(t) and t or s!=t and f(t) or f(t,i+1)को -4 बाइट्स के लिए संघनित किया जा सकता है

— क्वेलकेलेफ़

एक और 2 बाइट्स को बदलकर return t if i>len(t)else s!=t and f(t)or f(t,i+1))

— मुंडन

इससे भी अधिक e=s==t;return i>len(t)and t or f(t,i*e+e)और तब आप i=0फ़ंक्शन की परिभाषा को हटा सकते हैं , लेकिन आपको 0 प्रारंभ के साथ कॉल करना होगा।

— क्वेलकफ

मैं मान रहा हूँ कि चार स्थान वहाँ हैं क्योंकि आप चार स्थानों का उपयोग नहीं कर रहे हैं, लेकिन क्योंकि SE स्वचालित रूप से उनका विस्तार करता है। यदि ऐसा नहीं है, तो आप अपने सभी स्थानों को या तो टैब या -9 बाइट्स के लिए एकल स्थान बदल सकते हैं।

— निधि मोनिका का मुकदमा

@Quelklef मेटा अतिरिक्त मापदंडों को लेने से मना करता है।

— mbomb007

Answer 5

पर्ल 53 52

-P के लिए +1 शामिल है

for($i=0;$i<length;){$i=(s/(.).{$i}\1/\1/)?0:$i+1;}

इसे आइडोन पर आज़माएं ।

Answer 6

गणितज्ञ, 101 बाइट्स

NestWhile[i=0;StringReplace[#,a_~~_~RepeatedNull~i++~~a_:>a,1]&,#,SameQ,2,ByteCount@#]&~FixedPoint~#&

इसे कम करने का एक तरीका होना चाहिए ...

Answer 7

PHP, 90 बाइट्स

for($s=$argv[$c=1];$s[$i=++$i*!$c];)$s=preg_replace("#(.).{{$i}}\\1#","$1",$s,1,$c);echo$s;

या 92 बाइट्स

for($s=$argv[1];$s[$i];$i=++$i*!$c)$s=preg_replace("#(.).{".+$i."}\\1#","$1",$s,1,$c);echo$s;   

Comments

1) पहला संस्करण: (-2) के +$iबजाय $i+=0। 2) forलूप के बजाय whileदो बाइट्स बचा सकते हैं और कर्ल (-4) को हटाने की अनुमति देते हैं। 3) के $i=++$i*!$cबजाय $i=$c?0:$i+1(-1)। 4) \\2की जरूरत नहीं है, कोष्ठक (-2) को हटा दें। 5) आप गति 9के 1लिए (+0) के बजाय सीमा की अनुमति दे सकते हैं

— टाइटस

@ बहुत अच्छे आइडियाज देखें। मैंने यह धन्यवाद नहीं देखा था

— Jörg Hülsermann

अब जब कि मैं फिर से सोचता हूँ ... +$iहर मामले में काम नहीं करता है। कोशिश करो hammer। PHP रेगेक्स में खाली ब्रेसिज़ के बारे में शिकायत नहीं करता है; लेकिन यह वांछित के रूप में मेल नहीं खाता है। वैसे: मैं 91 की गिनती करता हूं, 90 की नहीं। लेकिन नया 1 आजमाएं)for($s=$argv[$c=1];$s[$i=++$i*!$c];)

— टाइटस

@ टिट्स हां वास्तव में मैं वापस जाता हूं $i+=0और बाद में आपके प्रस्ताव का प्रयास करूंगा। हथौड़े से क्या मतलब है?

— जार्ज हुल्सरमन

@ ठीक उसी समस्या को ठीक है अगर puzzleया कुछ और पसंद है (.)//1लेकिन यह आपके प्रस्ताव के साथ ठीक है या$i´=0

— Jörg Hülsermann

Answer 8

रूबी, 75 64 57 बाइट्स

(कोड + pकमांड लाइन विकल्प के 56 बाइट्स ।)

प्रतिस्थापित होने वाले मैचों की लंबाई को नियंत्रित करने के लिए एक रेगेक्स के अंदर स्ट्रिंग प्रक्षेप का उपयोग करना।

i=0
~/(.).{#{i}}\1/?sub($&,$1)&&i=0: i+=1while i<$_.size

परीक्षा:

$ ruby -p condense.rb <<< fnabnfun
fun

Answer 9

हास्केल , 97 88 बाइट्स

(0?)
(a:s)!(b:t)|a==b=a:t|1<3=a:s!t
s!_=s
m?s|length s<m=s|a<-s!drop m s=sum[m+1|a==s]?a

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

---

पुराना 97 बाइट

(a:s)!(b:t)|a==b=a:t|1<3=a:s!t
s!_=s
m?s|length s==m=s|a<-s!drop m s=(last$0:[m+1|a==s])?a
c=(0?)

इसे आइडोन पर आज़माएं ।

स्पष्टीकरण:

(a:s)!(b:t)|a==b = a:t         --perform condensation
           |1<3  = a:s!t       --recursively compare further
 s   ! _         = s           --no condensation performed

(!)कार्य एक एन-संक्षेपण जब एक बार पूरे और पहली n हटाया वर्ण, जैसे के साथ एक बार एक स्ट्रिंग दिया abcdbeऔर cdbeरिकर्सिवली दो प्रमुख पात्रों की तुलना द्वारा एक 2-संक्षेपण के लिए,।

m?s|length s==m   = s         --stop before performing length-s-condensation
   |a <- s!drop m s           --a is the m-condensation of s
    = (last$0:[m+1|a==s])?a   --disguised conditional:
                              -- if a==s       if the m-condensation did not change s
                              -- then (m+1)?a  then perform m+1-condensation
                              -- else 0?a      else restart with a 0-condensation

c=(0?)                        -- main function, initialise m with 0