चुनौती

पूर्णांकों की सूची को देखते हुए, आसन्न समान वस्तुओं के सभी जोड़े को बार-बार हटाने के बाद इन पूर्णांकों की सूची लौटाएं।

ध्यान दें कि यदि आपके पास विषम संख्या में समान संख्या में रन हैं, तो उनमें से एक जोड़ी का हिस्सा नहीं रह जाएगा।

उदाहरण:

[0, 0, 0, 1, 2, 4, 4, 2, 1, 1, 0]

सबसे पहले, आप को दूर करना चाहिए 0, 0, 4, 4और 1, 1पाने के लिए:

[0, 1, 2, 2, 0]

अब, आपको निकालना चाहिए 2, 2:

[0, 1, 0]

और यह अंतिम परिणाम है।

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

[] -> []
[१] -> [१]
[१, १] -> []
[१, २] -> [१, २]
[११, ११, ११] -> [११]
[१, २२, १] -> [१, २२, १]
[-31, ४६, -३१, ४६] -> [-३१, ४६, -३१, ४६]
[१, ०, ०, १] -> []
[५, ३, १०, १०, ५] -> [५, ३, ५]
[५, ३, ३, ३, ५] -> [५, ३, ५]
[0, -2, 4, 4, -2, 0] -> []
[0, 2, -14, -14, 2, 0, -1] -> [-1]
[0, 0, 0, 1, 2, 4, 4, 2, 1, 1, 0] -> [0, 1, 0]
[३, ५, ४, ४, 4, २६, २६, 4, ५] -> [३]
[-89,, ९, -87,-,, 89,>,>] -> [-89,, ९,-,,--,,,,]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है!

code-golf array-manipulation

— musicman523
स्रोत

सैंडबॉक्स उन लोगों के लिए जो डिलीट किए गए पोस्ट देख सकते हैं

— Musicman523

इससे कोई फर्क नहीं पड़ता, वे सभी समान हैं। इस वाक्यांश का अर्थ यह है कि[14, 14, 14][14]

— संगीतज्ञ ५२३

चुनौती को क्षमा करें, क्षमा करें। सोचा कि आप सभी जोड़ों को (1 से बढ़ती संख्या के दूर करने के लिए किया था 1,2, 11,12, आदि)

— स्टीफन

क्या हम एक सीमांकित स्ट्रिंग के रूप में इनपुट ले सकते हैं?

— झबरा

2

क्या आप एक परीक्षण मामला जोड़ सकते हैं -89,89,-87,-8,-88? मेरे (अनपोस्टेड) जैप सॉल्यूशन और फ्राई के रेटिना सॉल्यूशन दोनों ही फेल होते हैं --87,8।

— झबरा

5

जेली , 10 बाइट्स

Œgœ^/€FµÐL

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

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

Œgœ^/€FµÐL  Main link. Argument: A (array)

       µ    Combine all links to the left into a chain.
Œg              Group all adjacent equal items.
    /€          Reduce each group by...
  œ^                symmetric multiset difference.
                In each step, this maps ([], n) to [n] and ([n], n) to [], so the
                group is left with a single item if its length is odd, and no items
                at all if its length if even.
      F         Flatten the resulting array of singleton and empty arrays.
        ÐL  Apply the chain until the results are no longer unique. Return the last
            unique result.

— डेनिस
स्रोत

Ẏइसके बजाय का उपयोग करने से Fआप अपनी सूची में सूचियों का भी समर्थन करेंगे।

— एर्ग आउटफोलर जूल

नहीं, यहां œ^पूर्णांक-से-सरणी प्रचार पर निर्भर करता है। चूँकि 1D सरणियों को 2D सरणियों में पदोन्नत नहीं किया जाता है, इसलिए यह संख्याओं के अलावा कुछ भी काम नहीं करेगा।

— डेनिस

हे ... मेरा मतलब है कि आप बस इस्तेमाल कर सकते हैं ŒgWẎ$œ^/$€ẎµÐL... ओह रुको यह बहुत भोला है। : पी

— एरिक आउटगॉल्फ जूल

4

रेटिना ,17 15 बाइट्स

+m`^(.+)¶\1$¶?

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

नील और मार्टिन के लिए धन्यवाद 2 बाइट्स सहेजे गए!

प्रत्येक जोड़ी की संख्या को कुछ नहीं के साथ बदल देता है। यह प्रक्रिया तब तक चलती है जब तक कोई बदलाव नहीं किया जाता है।

— FryAmTheEggman
स्रोत

इसे खोलने से पहले जाप में एक समान समाधान तैयार किया। दुर्भाग्य से, हम दोनों इनपुट पर विफल हैं -89 89 -87 -88 -88, जैसे कि आउटपुट --87।

— झबरा

1

@ शगुन थैंक्स, मैंने इसे एक बाउंड्री चेक जोड़कर और नेगेटिव्स _को दर्शाने के लिए सही किया , जैसा कि कुछ भाषाओं में आम है।

— फ्राईमई इगमैन

जब से मुझे पता चला है कि यह भी _89 89 _87 _8 _88आउटपुट पर विफल रहेगा _89 89 _87 8। क्षमा करें: \

— झबरा

@Saggy क्षमा करें! समस्या खोजने के लिए धन्यवाद! मैंने उस मामले को ठीक करने के लिए एक और सीमा जाँच जोड़ी।

— FryAmTheEggman

1

@FryAmTheEggman सुनिश्चित नहीं हैं कि क्या उस के क्या नील का मतलब है, लेकिन आप तब भी इस्तेमाल कर सकते हैं mबारी करने \bमें रों ^और $।

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

3

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

यह बार-बार समान आसन्न तत्वों के जोड़े हटाता है, a_,a_जब तक कि कोई भी शेष न हो।

#//.{b___,a_,a_,c___}:>{b,c}&

— DavidC
स्रोत

3

पायथन 2 , 57 बाइट्स

r=[]
for x in input():r+=x,;r[-2:]*=r[-2:-1]!=[x]
print r

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

Iteratively अगले तत्व को जोड़कर आउटपुट सूची का निर्माण करता है, फिर अंत में कटा हुआ अगर एपिंग तत्व इसके पहले एक के बराबर होता है। दूसरे-से-अंतिम तत्व की जाँच करना r[-2:-1]!=[x]अजीब लगता है क्योंकि यह संभव है कि सूची की लंबाई केवल 1 है।

— XNOR
स्रोत

बहुत बढ़िया जवाब, अच्छी तरह से किया :)

— संगीतकार ५२३

2

जेली , 15 बाइट्स

Œr;ṪḂ$$€x/€FµÐL

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

व्याख्या

Œr;ṪḂ$$€x/€FµÐL  Main Link
Œr               Run-length encode
  ;              Concatenate (?)
       €         For each element
   ṪḂ$$          Is the last element odd?
          €      For each element    // Non-breaking alternative
        x/       Reduce by repeating // for run-length decode
           F     Flatten
            µ    (New monadic link)
             ÐL  Repeat until results are no longer unique

-1 बाइट मील के लिए धन्यवाद, और तय :)

— HyperNeutrino
स्रोत

@FryAmTheEggman फिक्स्ड; धन्यवाद!

— हाइपरन्यूट्रीनो

मुझे यकीन नहीं है कि एक त्रुटि को फेंकने और आउटपुट को एक सही समाधान के रूप में खाली मायने रखता है। आप ValueError: not enough values to unpack (expected 2, got 0)परीक्षण मामले के लिए कार्यक्रम फेंकते हैं [1,2,2,1]। यह भी ध्यान दें कि खाली आउटपुट अलग है []और 2से अलग है [2]।

13 बाइट्स के साथ Œr;ṪḂ$$€ŒṙµÐL। त्रुटि से बचने के लिए, रन-लेंथ डिकोड के बाद से प्रतिस्थापित Œṙकरें x/€Fजब एक खाली सूची दी जाती है तो एक त्रुटि होती है। एक सूची के रूप में आउटपुट को देखने के लिए, निपटने ŒṘसे यह दिखाई देगा।

— मील

@ ThePirateBay जेली की एक खाली सूची का प्रतिनिधित्व है - एक आइटम का खाली, - बस वह आइटम, और कई मदों का - एक ब्रैकेटेड और अल्पविराम से अलग सूची। सबमिशन एक लिंक (फंक्शन) का होता है न कि एक फुल प्रोग्राम का (ज्यादा लम्बा जैसा पाइथन में होता है) - ÇŒṘअंतिम लिंक को कॉल करने के लिए फूटर में एक और "सामान्य" व्यू प्लेस देखने के लिए ( Ç) और पाइथन रिप्रेजेंटेशन को प्रिंट करना ( ŒṘ) । त्रुटि हालांकि स्वीकार्य नहीं हो सकती है।

— जोनाथन एलन

@JonathanAllan। ठीक है, मुझे एहसास हुआ कि एक सूची में जेली का स्ट्रिंग प्रतिनिधित्व स्वीकार्य है। मेरी पहली टिप्पणी का मुख्य बिंदु यह उल्लेख करना है कि सूची खाली होने पर त्रुटि डाली गई है।

2

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

सहेजे गए 1 बाइट @ @PirateBay के लिए धन्यवाद

f=a=>1/a.find(q=>q==a[++i],i=-2)?f(a,a.splice(i,2)):a

Naive पुनरावर्ती समाधान, कामचलाऊ हो सकता है।

— ETHproductions
स्रोत

आप वर्तमान और पिछले तत्व के बजाय वर्तमान और अगले एक जाँच कर सकते हैं, तो आप बदल सकते हैं i=0के साथ i=-2और i-1साथ iहै जो -1 में कुल बाइट।

@ Guest44851 धन्यवाद, लेकिन ... इसका मतलब यह नहीं है कि मुझे इसे बदलने की आवश्यकता होगी i+1? (मैंने इसे ++अच्छी तरह से आगे बढ़ने से पहले कोशिश की और यह पता नहीं लगा सका, हालांकि मेरे पास ऐसा करने के लिए केवल एक मिनट था)

— ETHproductions

आप देख सकते हैं कि यह ठीक से काम करता है ।

@ ThePirateBay हंसमुख होकर, आप सही कह रहे हैं! पर कैसे?

— ETHproductions

2

पायथन 2 , 73 बाइट्स

चूंकि मेरे पास टिप्पणी करने के लिए पर्याप्त प्रतिष्ठा नहीं है: मैंने बाइट को बचाने के लिए l (r) के बजाय r =! का उपयोग करने के लिए @officialaimm का उत्तर बदल दिया। आपके लिए बहुत चतुर समाधान, @officialaimm!

r=[]                            # create list that will hold final results. A new list is important because it needs to be removable.
for i in input():               
 if r!=[]and r[-1]==i:r.pop()   # Ensure that we have at least 1 char added to the list (r!=[])... or that the last character of our final result isn't the current character being scanned. If that is, well, remove it from the final list because we do not want it anymore
 else:r+=[i]                    # Shorthand for r.append(i). This adds i to the final result
print r

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

यह, फिर से, बहुत देर हो चुकी है ... मैं अभी भी क्यों उठ रहा हूं?

— राफेल कोट
स्रोत

2

अजगर, ६० 58 बाइट्स

f=lambda a:a and(a[:1]+f(a[1:]))[2*(a[:1]==f(a[1:])[:1]):]

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

— एंडर्स कसीगोर
स्रोत

[a[0]]हैa[:1]

— xnor

@xnor तो यह है। धन्यवाद!

— एंडर्स कासोर्ग

2

MATL , 7 बाइट्स

t"Y'oY"

कुछ परीक्षण मामलों के लिए जहां परिणाम खाली है कार्यक्रम त्रुटि के साथ बाहर निकलता है, लेकिन किसी भी मामले में यह सही (खाली) आउटपुट का उत्पादन करता है।

इसे ऑनलाइन आज़माएं! या गैर-खाली आउटपुट के साथ परीक्षण मामलों को सत्यापित करें ।

व्याख्या

t     % Implicit input. Duplicate
"     % For each (i.e. do as many times as input size)
  Y'  %   Run-length encode. Gives array of values and array of run lengths
  o   %   Parity, element-wise. Reduces run-lengths to either 0 or 1
  Y"  %   Run-length decode. Gives array of values appearing 0 or 1 times;
      %   that is, removes pairs of consecutive values
      % Implicit end. Implicit display

इनपुट पर विचार करें

0 0 0 1 2 4 4 2 1 1 0

प्रत्येक पुनरावृत्ति निरंतर जोड़े के जोड़े को हटा देती है। पहला पुनरावृति सरणी को घटाता है

0 1 2 2 0

दो मान 2जो अब आसन्न हैं, प्रारंभिक सरणी में आसन्न नहीं थे। इसलिए दूसरे पुनरावृत्ति की आवश्यकता है, जो देता है:

0 1 0

आगे पुनरावृत्तियों इस अपरिवर्तित छोड़ देंगे। आवश्यक पुनरावृत्तियों की संख्या इनपुट आकार द्वारा ऊपरी-बाध्य है।

खाली मध्यवर्ती परिणाम रन-लेंथ डिकोडिंग फ़ंक्शन का कारण बनता है (Y" भाषा के वर्तमान संस्करण में त्रुटि के ) का ; लेकिन ouput आवश्यकतानुसार खाली है।

— लुइस मेंडो
स्रोत

क्या आप एक स्पष्टीकरण जोड़ सकते हैं? मैं यह समझना चाहता हूं कि आपने मुझे इतनी खूबसूरती से कैसे हराया। : पी

— डेनिस

@ डेनिस ज़रूर! मैं भूल गया था। संपन्न :-)

— लुईस मेन्डो

1

आह, आरएलई दो सरणियों को धक्का देता है । यह उपयोगी है।

— डेनिस

2

x86 मशीन कोड (32-बिट संरक्षित मोड), 36 बाइट्स

52
8B 12
8D 44 91 FC
8B F9
8D 71 04
3B F0
77 10
A7
75 F9
83 EF 04
4A
4A
A5
3B F8
75 FB
97
EB E7
58
89 10
C3

मशीन कोड के उपरोक्त बाइट्स एक फ़ंक्शन को परिभाषित करते हैं जो एक सरणी को इनपुट के रूप में लेता है, आसन्न डुप्लिकेट को जगह में ढहता है, और कॉल करने वाले को बिना परिणाम लौटाता है। यह __fastcallकॉलिंग कन्वेंशन का अनुसरण करता है , क्रमशः ECXऔर EDXरजिस्टरों में दो मापदंडों को पारित करता है।

पहला पैरामीटर ( ECX) 32-बिट पूर्णांक के सरणी में पहले तत्व के लिए एक संकेतक है (यदि सरणी खाली है, तो यह मेमोरी में कहीं भी इंगित कर सकता है)। दूसरा पैरामीटर ( EDX) 32-बिट पूर्णांक के लिए एक सूचक है जिसमें सरणी की लंबाई होती है।

यदि आवश्यक हो तो फ़ंक्शन सरणी के तत्वों को संशोधित करेगा, और ढह गई सरणी की नई लंबाई को इंगित करने के लिए लंबाई भी अपडेट करेगा। इनपुट लेने और आउटपुट वापस करने के लिए यह एक असामान्य तरीका है, लेकिन वास्तव में आपके पास असेंबली भाषा में कोई दूसरा विकल्प नहीं है। सी के रूप में, सरणियों को वास्तव में पहले तत्व और एक लंबाई के सूचक के रूप में भाषा में दर्शाया जाता है । यहाँ एक ही चीज़ थोड़ी अजीब है जो संदर्भ द्वारा लंबाई ले रही है , लेकिन अगर हमने ऐसा नहीं किया, तो सरणी को छोटा करने का कोई तरीका नहीं होगा। कोड ठीक काम करेगा, लेकिन आउटपुट में कचरा होगा, क्योंकि कॉलर को पता नहीं होगा कि ढह गए सरणी से प्रिंटिंग तत्वों को कहां रोकना है।

असेंबली असेंबली mnemonics:

; void __fastcall CollapseAdjacentDuplicates(int * ptrArray, int * ptrLength);
; ECX = ptrArray              ; ECX = fixed ptr to first element
; EDX = ptrLength
   push  edx                  ; save pointer to the length
   mov   edx, [edx]           ; EDX = actual length of the array
   lea   eax, [ecx+edx*4-4]   ; EAX = fixed ptr to last element 

FindAdjacentPairs:
   mov   edi, ecx             ; EDI = ptr to element A
   lea   esi, [ecx+4]         ; ESI = ptr to element B
FindNext:
   cmp   esi, eax             ; is ptr to element B at end?
   ja    Finished             ; if we've reached the end, we're finished
   cmpsd                      ; compare DWORDs at ESI and EDI, set flags, and increment both by 4
   jne   FindNext             ; keep looping if this is not a pair

; Found an adjacent pair, so remove it from the array.
   sub   edi, 4               ; undo increment of EDI so it points at element A
   dec   edx                  ; decrease length of the array by 2
   dec   edx                  ;  (two 1-byte DECs are shorter than one 3-byte SUB)
RemoveAdjacentPair:
   movsd                      ; move DWORD at ESI to EDI, and increment both by 4
   cmp   edi, eax             ; have we reached the end?
   jne   RemoveAdjacentPair   ; keep going until we've reached the end
   xchg  eax, edi             ; set new end by updating fixed ptr to last element
   jmp   FindAdjacentPairs    ; restart search for adjacent pairs from beginning

Finished:
   pop   eax                  ; retrieve pointer to the length
   mov   [eax], edx           ; update length for caller
   ret

कार्यान्वयन से प्रेरित था मेरे C ++ 11 उत्तर , लेकिन असेंबली में फिर से लिखा गया, आकार के लिए अनुकूलन। असेंबली बहुत बेहतर गोल्फिंग भाषा है। :-)

नोट: क्योंकि इस कोड स्ट्रिंग निर्देश का उपयोग करता है, है है मान लेते हैं कि दिशा झंडा स्पष्ट (है DF== 0)। यह अधिकांश ऑपरेटिंग वातावरण में एक उचित धारणा है, क्योंकि एबीआई में आमतौर पर डीएफ स्पष्ट है। यदि यह गारंटी नहीं दी जा सकती है, तो कोड के शीर्ष पर एक 1-बाइट CLDअनुदेश ( 0xFC) डालने की आवश्यकता है।

यह भी, जैसा कि कहा गया है, 32-बिट संरक्षित मोड-विशेष रूप से, एक "फ्लैट" मेमोरी मॉडल मानता है, जहां अतिरिक्त खंड ( ES) डेटा खंड ( DS) के समान है।

— कोडी ग्रे
स्रोत

1

बैच, 133 बाइट्स

@set s=.
:l
@if "%1"=="%2" (shift/1)else set s=%s% %1
@shift/1
@if not "%1"=="" goto l
@if not "%s:~2%"=="%*" %0%s:~1%
@echo(%*

मैंने सेट किया .क्योंकि बैच केवल अगर डुप्लिकेट हैं तो भ्रमित हो जाता है। मुझे इसका उपयोग भी करना है shift/1ताकि मैं %0%s:~1%तर्क सूची को नए सरणी और लूप में सेट करने के लिए उपयोग कर सकूं।

— नील
स्रोत

मुझे पूछना है ... क्यों? अच्छा जवाब ... लेकिन क्यों?

— ज़ाचरी

@ Zacharý क्योंकि यह वहाँ है।

— नील

1

@ Zacharý भाग में, गैर-गोल्फ भाषाओं में गोल्फ का एक अच्छा कारण है क्योंकि यह वास्तव में उपयोगी हो सकता है । कोई भी ऐसा करने के लिए वास्तविक जीवन में जेली दुभाषिया को आग लगाने वाला नहीं है, लेकिन उन्हें इसे एक बैच फ़ाइल में करने की आवश्यकता हो सकती है!

— कोडी ग्रे

ओह। यह समझ आता है।

— जकार्इ

1

जेली , 12 बाइट्स

ŒgṁLḂ$$€ẎµÐL

संख्याओं की सूची लेने और वापस करने का एक विचित्र लिंक।

इसे ऑनलाइन आज़माएं! या देखें परीक्षण सूट

कैसे?

ŒgṁLḂ$$€ẎµÐL - Link: list
         µÐL - perform the chain to the left until no changes occur:
Œg           -   group runs (yield a list of lists of non-zero-length equal runs)
      $€     -   last two links as a monad for €ach run:
     $       -     last two links as a monad:
   L         -       length (of the run)
    Ḃ        -       modulo 2 (1 if odd, 0 if even)
  ṁ          -     mould (the run) like (1 or 0) (yields a list of length 1 or 0 lists)
        Ẏ    -   tighten (make the list of lists into a single list)

— जोनाथन एलन
स्रोत

ṁLḂ$$€के समतुल्य है, ḣLḂ$$€जिसके समतुल्य ṫḊ¿€3$आप ṫḊ¿€3डाईड / निलाड जोड़ी बनाने के लिए यहाँ से बदल सकते हैं ।

— निकोल

उदाहरण के लिए, लंबाई के रन के साथ एक इनपुट के साथ काम नहीं करता है। 4. लूप के प्रत्येक पुनरावृत्ति पर छल के लिए इनपुट क्या है?

— जोनाथन एलन

आपको 0 या 1 तत्वों के साथ एक सूची के साथ छोड़ दिया जाना चाहिए। अगर लेन (x) == 1, तो Ḋवापस आ जाएगी [], जबकि अगर लेन (x) == 0 Ḋवापस आ जाएगी 0, दोनों किया जा रहा falsy मूल्यों। इनपुट Ḋवर्तमान मूल्य का है, और ṫवर्तमान मूल्य बाएं तर्क के 3रूप में और दाईं ओर होगा। यदि len (x) == 4 है, तो यह आपके साथ छोड़ने ṫ3ṫ3या ṫ5छोड़ने के समान होगा []।

— आउटगोल्फ जूल

मैं देख सकता हूं कि यह क्या करना चाहिए, लेकिन क्या xआपके विवरण में वर्तमान मूल्य है? आकार के लिए इसे आज़माएं ।

— जोनाथन एलन

सच कहूं तो मुझे नहीं पता कि यह कोड है या बग :)

— जोनाथन एलन

1

जाप , 34 बाइट्स

ó¥ k_l vÃ®ò k_l É}Ãc
ó¥ l ¥Ul ?U:ß

पुनरावर्ती समान संख्या के जोड़े निकालता है जब तक कोई भी मौजूद न हो।

इसे ऑनलाइन आज़माएं! उसके साथ-Qआउटपुट सरणी को फ़्लैग करने के ध्वज के ।

मेरे WIP CodePen का उपयोग करके सभी परीक्षण मामलों को चलाएँ ।

— जस्टिन मेरिनर
स्रोत

1

05AB1E , 15 बाइट्स

[γʒgÉ}€нÐγ‚€gË#

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

व्याख्या

[γʒgÉ}€нÐγ‚€gË#
[               # Start infinite loop
 γ              # Group Array into consecutive equal elements
  ʒgÉ}          # Keep the subarrays with an uneven amount of elements
      €н        # Keep only the first element of each subarray
        Ð       # Triplicate the result on the stack
         γ      # Group the top element into consecutive equal elements
          ‚     # Wrap the top two items of the stack in an array
           €g   # Get the length of each subarray
             Ë# # Break if they are equal
                # Implicit print

— Datboi
स्रोत

1

05AB1E , 13 बाइट्स

[DγʒgÉ}€нDŠQ#

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

स्पष्टीकरण:

[DγʒgÉ}€нDŠQ# Implicit input
[             Start infinite loop
 D            Duplicate
  γ           Split into chunks of equal elements
   ʒ  }       Filter by
    g           Length
     É          Odd? (0=falsy 1=truthy)
       €      Foreach command
        н     Head
         D    Duplicate
          Š   Push c, a, b
           Q  Equal? (0=falsy 1=truthy)
            # Break if true (i.e. equal to 1)

— आउटगोल्फर को एरिक करें
स्रोत

1

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

a!(b:c)|a==b=c
a!b=a:b
foldr(!)[]

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

— एंडर्स कसीगोर
स्रोत

1

अजगर 2 , 74 70 66 बाइट्स

4 बाइट्स के लिए धन्यवाद @SteamyRoot: rइसके बजाय len(r)सूची / स्टैक के खालीपन की जांच करने के लिए पर्याप्त है।
4 बाइट्स के लिए धन्यवाद @ov: बेहतर अगर हालत [i]==r[-1:]

पायथन 2 , 66 बाइट्स

r=[]
for i in input():
 if[i]==r[-1:]:r.pop()
 else:r+=[i]
print r

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

— officialaimm
स्रोत

1

यदि इसका उद्देश्य len(r)सिर्फ यह जांचना है कि सूची खाली है या नहीं, तो आपको इसे केवल द्वारा प्रतिस्थापित करने में सक्षम होना चाहिए r, मुझे लगता है?

— स्टीमीयूट

अरे हाँ, धन्यवाद।

— आधिकारिक

1

66 बाइट्स

— ovs

@ovs बहुत बहुत धन्यवाद, यह बहुत बढ़िया है! (y)

— आधिकारिक

1

वैकल्पिक 66 बाइट्स लंबे संस्करण , हालांकि केवल तीन लाइनों की आवश्यकता होती है।

— जोनाथन फ्रेच

0

क्लोजर, 100 बाइट्स

#(loop[i % j[]](if(= i j)i(recur(mapcat(fn[p](repeat(mod(count p)2)(last p)))(partition-by + i))i)))

यकीन नहीं होता कि यह सबसे कम संभव है।

— NikoNyrh
स्रोत

0

बैश, 82 बाइट्स

cat>b
while cat b>a
perl -pe 's/(\d+) \1( |$)//g' a>b
! diff a b>c
do :
done
cat a

शायद उन सभी में से एक रास्ता है cat, लेकिन मुझे यह नहीं पता है।

— NighttimeDriver50000
स्रोत

0

भूसी , 10 बाइट्स

ωoṁS↑o%2Lg

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

व्याख्या

ωoṁS↑o%2Lg
ω           Repeat until fixed point
 o          the following two functions:
         g   a) group adjacent elements
  ṁ          b) map over groups and concatenate:
        L     length of group
     o%2      mod 2
   S↑         take that many elements of group

— Zgarb
स्रोत

0

PHP, 81 बाइट्स

    function f(&$a){for($i=count($a);--$i;)$a[$i]-$a[$i-1]||array_splice($a,$i-1,2);}

फ़ंक्शन, संदर्भ से कॉल करें या इसे ऑनलाइन आज़माएं ।

खाली इनपुट के लिए विफल रहता है; डालने के लिए $i&&या ठीक करने से $a&&पहले --$i।

— टाइटस
स्रोत

0

वी , 10 बाइट्स

òÍ¨.«©î±î*

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

संपीड़ित रेगेक्स :%s/$.\+$\n\1\n*:। वैकल्पिक न्यूलाइन इतनी है कि यह फाइल के अंत में भी काम करती है। अगर मुझे लगता है कि अंत के बाद एक नई रूपरेखा है तो यह 8 बाइट्स होगा ... लेकिन यह एक खिंचाव जैसा लगता है

— nmjcman101
स्रोत

0

डीसी , 84 78 बाइट्स

[L.ly1-dsy0<A]sA[LtLtS.ly1+sy]sP[dStrdStr!=Pz1<O]sO[0syzdsz1<Oly0<Azlz>M]dsMxf

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

स्पष्टता के कुछ प्रयास में इसे थोडा अनपैक करते हुए, क्रम से बाहर:

[0syzdsz1<Olydsx0<Alx1+lz>M]dsMxfमुख्य मैक्रो 0 पर Mसेट होता है y, स्टैक पर वस्तुओं की संख्या को पुनः प्राप्त करता है, इसे रजिस्टर में संग्रहीत करता है z, फिर मैक्रो चलाता है Oयदि स्टैक पर कम से कम दो आइटम हैं। एक बार Oखत्म होने के बाद, यह काउंटर को लोड करता है yऔर यह xसुनिश्चित करने के लिए जाँच करने से पहले इसे रजिस्टर में कॉपी करता है कि yनॉनज़रो है (जिसका अर्थ है स्टैक .में डेटा है)। यदि यह मामला है, तो यह मैक्रो चलाता हैA । अंत में यह जांचता है कि क्या मूल स्टैक का आकार मौजूदा स्टैक आकार से बड़ा है और यदि ऐसा है तो पुन: पुन: लोड हो जाता है। एक बार जब यह समाप्त हो जाता है, तो यह स्टैक को प्रिंट करता हैf ।
[dStrdStr!=Pz1<O]sOमैक्रो Oअस्थायी रूप से स्टैक पर शीर्ष दो वस्तुओं को स्टोर करता है t। यह तब शीर्ष दो वस्तुओं की तुलना करता है और मैक्रो चलाता हैP यदि वे समान नहीं हैं। अंत में यह जांचता है कि स्टैक पर कम से कम दो आइटम हैं या नहीं, और यदि ऐसा है तो स्वयं चलाता है।
[LtLtS.ly1+sy]sPमैक्रो Pस्टैक से दो आइटम लेता है t, मुख्य स्टैक पर शीर्ष एक को पीछे धकेलता है, और स्टैक पर निम्नलिखित एक को धक्का देता है .। यह फिर काउंटर बढ़ाता हैy ।
[L.ly1-dsy0<A]sAमैक्रो Aस्टैक लेता है .और इसे प्राथमिक स्टैक में बदल देता है। यह करता है कि, decrementing काउंटरy जब तक कुछ भी धक्का नहीं छोड़ा जाता तब तक ।

स्पष्टीकरण के लिए संपादित किया गया है, और 6 बाइट्स को बंद करने के लिए क्योंकि मैं अनावश्यक रूप से स्टैक के आकार को संग्रहीत कर रहा था।

— brhfl
स्रोत

0

सी ++ 11, 161 बाइट्स

#include<vector>
#include<algorithm>
using V=std::vector<int>;void f(V&v){V::iterator i;while((i=std::adjacent_find(v.begin(),v.end()))!=v.end())v.erase(i,i+2);}

उपरोक्त कोड एक फ़ंक्शन को परिभाषित करता है f, जो कि एक std::vector<int>संदर्भ द्वारा लेता है , इसे विनिर्देश के अनुसार आसन्न डुप्लिकेट को ढहाने के लिए जगह में संशोधित करता है, और फिर लौटता है।

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

इससे पहले कि मैं बाइट की गिनती की जाँच करता, मुझे लगा कि यह बहुत ही सुंदर कोड है। 150 से अधिक बाइट्स, हालांकि, इतना अच्छा नहीं है! या तो मैं गोल्फ में बहुत अच्छा नहीं हूं, या सी ++ बहुत अच्छी गोल्फिंग भाषा नहीं है ...

Ungolfed:

#include <vector>
#include <algorithm>

using V = std::vector<int>;

void f(V& v)
{
   V::iterator i;

   // Use std::adjacent_find to search the entire vector for adjacent duplicate elements.
   // If an adjacent pair is found, this returns an iterator to the first element of the
   // pair so that we can erase it. Otherwise, it returns v.end(), and we stop.
   while ((i=std::adjacent_find(v.begin(), v.end())) != v.end())
   {
        v.erase(i, i+2);   // erase this adjacent pair
   }
}

— कोडी ग्रे
स्रोत

C ++ सबसे अच्छी गोल्फिंग भाषा नहीं है। का अच्छा उपयोग std::adjacent_find! मुझे आश्चर्य है कि अगर आप इस समारोह अपने आप को लागू किया है, तो यह कम हो सकता है, आप निकाल सकते हैं के बाद से #include <algorithm>के रूप में अच्छी तरह से

— musicman523

@ musicman523 मेरे पहले प्रयास ने इसे हाथ से लागू किया , हालांकि मैंने थोड़ा अलग एल्गोरिथ्म का उपयोग किया। मैं जो करना चाहता था, उसके क्रियान्वयन को अपना रहा था std::unique। लेकिन सभी तर्कों को करने के लिए बहुत सारे कोड लगते हैं, और जब मैं पार हुआ std::adjacent_find, तो यह स्पष्ट था कि कोड आकार के मामले में वह विजेता था।

— कोडी ग्रे

0

PHP, 74 बाइट्स

function c(&$a){foreach($a as$k=>$v)$a[$k+1]===$v&&array_splice($a,$k,2);}

सरणी को कम करने के लिए संदर्भ द्वारा फ़ंक्शन सी कॉल। इसे ऑनलाइन आज़माएं ।

दिलचस्प है कि यह Php5.6 में काम करता है लेकिन 7 नहीं।

— Progrock
स्रोत

0

आर , 57 54 बाइट्स

l=rle(scan());while(any(x<-!l$l%%2))l=rle(l$v[!x]);l$v

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

जोड़े को हटाने के लिए एक रन-लंबाई एन्कोडिंग का उपयोग करता है।

— ग्यूसेप
स्रोत

0

जे , 38 बाइट्स

;@(<@($~2|#)/.~0+/\@,}.~:}:)^:(0<#)^:_

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

— FrownyFrog
स्रोत

0

GNU sed , 19 + 1 = 20 बाइट्स

-rझंडे के लिए +1 बाइट ।

:
s/\b(\S+ )\1//g
t

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

— जॉर्डन
स्रोत

0

अजगर, 10 बाइट्स

पार्टी के लिए थोड़ा देर से।

ueMf%hT2r8

परीक्षण सूट।

— स्टीवन एच।
स्रोत

आसन्न डुप्लिकेट को संक्षिप्त करें

चुनौती

उदाहरण:

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

स्कोरिंग

जेली , 10 बाइट्स

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

रेटिना ,17 15 बाइट्स

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

पायथन 2 , 57 बाइट्स

जेली , 15 बाइट्स

व्याख्या

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

पायथन 2 , 73 बाइट्स

अजगर, ६० 58 बाइट्स

MATL , 7 बाइट्स

व्याख्या

x86 मशीन कोड (32-बिट संरक्षित मोड), 36 बाइट्स

बैच, 133 बाइट्स

जेली , 12 बाइट्स

कैसे?

जाप , 34 बाइट्स

05AB1E , 15 बाइट्स

व्याख्या

05AB1E , 13 बाइट्स

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

अजगर 2 , 74 70 66 बाइट्स

पायथन 2 , 66 बाइट्स

क्लोजर, 100 बाइट्स

बैश, 82 बाइट्स

भूसी , 10 बाइट्स

व्याख्या

PHP, 81 बाइट्स

वी , 10 बाइट्स

डीसी , 84 78 बाइट्स

सी ++ 11, 161 बाइट्स

PHP, 74 बाइट्स

आर , 57 54 बाइट्स

जे , 38 बाइट्स

GNU sed , 19 + 1 = 20 बाइट्स

अजगर, 10 बाइट्स