अन-द-डुप्लिकेटिंग स्ट्रिंग्स

Question

परिचय

आइए निम्नलिखित स्ट्रिंग देखें:

AABBCCDDEFFGG

आप देख सकते हैं कि पत्र को छोड़कर हर पत्र की नकल की गई है E। इसका मतलब है कि पत्र Eको डी-डुप्लिकेट किया गया है । तो, केवल एक चीज जो हमें यहाँ करने की ज़रूरत है, वह है उस प्रक्रिया को उल्टा करना, जो हमें निम्नलिखित अन-डी-डुप्लिकेटेड स्ट्रिंग देता है:

AABBCCDDEEFFGG

---

आइए एक कठिन उदाहरण लें:

AAAABBBCCCCDD

आप देख सकते हैं कि लगातार असमान संख्या है B, इसलिए इसका मतलब है कि BBमूल स्ट्रिंग से डी-डुप्लिकेट किया गया था। हमें केवल इस पत्र को डी-डुप्लिकेट करने की आवश्यकता है, जो हमें देता है:

AAAABBBBCCCCDD

चुनौती

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

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

AAABBBCCCCDDDD    -->    AAAABBBBCCCCDDDD
HEY               -->    HHEEYY
AAAAAAA           -->    AAAAAAAA
N                 -->    NN
OOQQO             -->    OOQQOO
ABBB              -->    AABBBB
ABBA              -->    AABBAA

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे कम वैध जमा है!

Comments

@ mbomb007 हां, यह परिणाम होगा AABBBB।

— अदनान

मुझे यकीन नहीं है कि मैं चुनौती को समझता हूं। ABBBनक्शा क्यों AABBBBनहीं है AABBBBBB?

— डेनिस

@ डेनिस यदि आप प्रत्येक वर्ण के समूह को 2 के समूह में विभाजित करते हैं, तो आपको निम्नलिखित मिलेगा A BB B:। जिन वर्णों को जोड़ा नहीं गया है (और इसलिए डुप्लिकेट नहीं किया गया है) को डुप्लिकेट करने की आवश्यकता है, जिसके परिणामस्वरूप AA BB BB, जो कि अन-डी-डुप्लिकेटेड स्ट्रिंग है।

— अदनान

तो: यह सुनिश्चित करें कि प्रत्येक रन के पात्रों में रन के अधिकांश तत्वों को जोड़कर एक समान तत्व है?

— मैड फिजिसिस्ट

@MadPhysicist हाँ, यह सही है

— अदनान

Answer 1

MATL , 7 बाइट्स

Y'to+Y"

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

'ABBA'उदाहरण इनपुट के रूप में लेते हैं ।

Y'   % Implicit input. Run-length decoding
     % STACK: 'ABA', [1 2 1]
t    % Duplicate top of the stack
     % STACK: 'ABA', [1 2 1], [1 2 1]
o    % Modulo 2
     % STACK: 'ABA', [1 2 1], [1 0 1]
+    % Add, element-wise
     % STACK: 'ABA', [2 2 2]
Y"   % Run-length encoding. Implicit display
     % STACK: 'AABBAA'

Answer 2

रेटिना , 11 बाइट्स

(.)\1?
$1$1

इसे ऑनलाइन आज़माएं - इसमें सभी परीक्षण मामले शामिल हैं

Comments

मुझे उम्मीद थी कि रेटिना जीत जाएगी।

— एडम

@ Adám हाँ, यह बहुत कम है, लेकिन यह MATL जवाब बहुत अच्छा है। सभी गोल्फ भाषाएँ छोटे समाधानों के साथ समाप्त हुईं।

— mbomb007

Answer 3

पर्ल, 16 बाइट्स

कोड + -pध्वज के 15 बाइट्स ।

s/(.)\1?/$1$1/g

इसे चलाने के लिए:

perl -pe 's/(.)\1?/$1$1/g' <<< 'HEY'

Answer 4

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

u(a:b:c)=a:a:u([b|a/=b]++c)
u x=x++x

प्रयोग उदाहरण: u "OOQQO"-> "OOQQOO"।

यदि स्ट्रिंग में कम से कम 2 तत्व हैं, तो पहले की दो प्रतियां लें और एक पुनरावर्ती कॉल के साथ जोड़ें

• दूसरा तत्व एक बाकी है अगर पहले दो तत्व अलग हैं या
• बस बाकी है

यदि दो तत्व (एक या शून्य) से कम हैं, तो सूची की दो प्रतियां लें।

Answer 5

ब्रेकीलॉग , 17 बाइट्स

@b:{~b#=.l#e,|}ac

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

व्याख्या

Example input: "ABBB"

@b                  Blocks: Split into ["A", "BBB"]
  :{          }a    Apply the predicate below to each element of the list: ["AA", "BBBB"]
                c   Concatenate: "AABBBB"

    ~b#=.             Output is the input with an additional element at the beginning, and
                        all elements of the output are the same (e.g. append a leading "B")
        .l#e,         The length of the Output is an even number
             |        Or: Input = Output (i.e. do nothing)

Answer 6

रूबी, 21 बाइट्स

20 बाइट्स -pध्वज के साथ।

gsub(/(.)\1?/){$1*2}

Answer 7

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

और अधिक कुशल '$ 1 $ 1' की तरह उपयोग करके 7 बाइट्स सहेजा [अन्य] [उत्तर] किया

s=>s.replace(/(.)\1?/g,'$1$1')

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

let f =

s=>s.replace(/(.)\1?/g,'$1$1')

console.log(f("AAABBBCCCCDDDD"));   //  -->  AAAABBBBCCCCDDDD
console.log(f("HEY"));              //  -->  HHEEYY
console.log(f("AAAAAAA"));          //  -->  AAAAAAAA
console.log(f("N"));                //  -->  NN
console.log(f("OOQQO"));            //  -->  OOQQOO
console.log(f("ABBB"));             //  -->  AABBBB
console.log(f("ABBA"));             //  -->  AABBAA

Answer 8

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

s=StringReplace;s[s[#,a_~~a_->a],b_->b~~b]&

एक स्ट्रिंग इनपुट करता है और एक स्ट्रिंग आउटपुट करता है। पूरी तरह से समर्पण तो पूरी तरह से undeduplicate। वास्तविक छोटा नहीं है, लेकिन मैं अभी के लिए बेहतर नहीं कर सकता।

Answer 9

Befunge 98 , 24 बाइट्स

#@~#;:::#@,~-:!j;$,;-\,;

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

$आसानी से बदला जा सकता है -, और 2 के @साथ ;।

मुझे लगता है कि यह -दोनों -,(या $,ऊपर) की शुरुआत में और आगे बढ़ने के कारण गोल्फ हो सकता है -\,।

कैसे?

Stack notation:  bottom [A, B, C, D] top

#@~     Pushes the first character onto the stack (C henceforth) and ends if EOF
#;      No-op to be used later
:::     Now stack is [C, C, C, C]

#@,~    Prints C, and if EOF is next (odd consecutive Cs), prints again and ends
        Lets call the next character D

-       Now stack is [C, C, C-D]
:!j;    If C == D, go to "$," Else, go to "-\,"

===(C == D)===

$,      C == D (i.e. a pair of Cs) so we discard top and print C (Stack is now [C])
;-\,;   Skipped, IP wraps, and loop starts again

===(C != D)===

-       Stack is [C, C-(C-D)]  By expanding: [C, C - C + D] or just [C, D]
\,      Prints C (Stack is now [D])

;#@~#;  This is skipped, because we already read the first character of a set of Ds,
        and this algorithm works by checking the odd character in a set of
        consecutive similar characters. We already read D, so we don't
        need to read another character.

Answer 10

जावा 7, 58 बाइट्स

String c(String s){return s.replaceAll("(.)\\1?","$1$1");}

Ungolfed:

String c(String s){
  return s.replaceAll("(.)\\1?", "$1$1");
}

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  static String c(String s){return s.replaceAll("(.)\\1?","$1$1");}

  public static void main(String[] a){
    System.out.println(c("AABBCCDDEFFGG"));
    System.out.println(c("AAAABBBCCCCDD"));
    System.out.println(c("AAABBBCCCCDDDD"));
    System.out.println(c("HEY"));
    System.out.println(c("AAAAAAA"));
    System.out.println(c("N"));
    System.out.println(c("OOQQO"));
    System.out.println(c("ABBB"));
    System.out.println(c("ABBA"));
  }
}

आउटपुट:

AABBCCDDEEFFGG
AAAABBBBCCCCDD
AAAABBBBCCCCDDDD
HHEEYY
AAAAAAAA
NN
OOQQOO
AABBBB
AABBAA

Answer 11

PHP, 65 बाइट्स, कोई रेगेक्स नहीं

while(""<$c=($s=$argv[1])[$i])if($c!=$s[++$i]||!$k=!$k)echo$c.$c;

कमांड लाइन तर्क से इनपुट लेता है। साथ चलाना -r।

regex? PHP में, ज्यादातर उत्तरों द्वारा उपयोग किए गए regex हर वर्ण को डुप्लिकेट करता है। 44 बाइट्स होंगे:

<?=preg_replace("#(.)\1?#","$1$1",$argv[1]);

Answer 12

ब्रेन-फ्लैक 69 बाइट्स

के लिए +3 शामिल है -c

{((({}<>))<>[({})]<(())>){((<{}{}>))}{}{(<{}{}>)}{}}<>{({}<>)<>}<>

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

स्पष्टीकरण:

Part 1:
{((({}<>))<>[({})]<(())>){((<{}{}>))}{}{(<{}{}>)}{}}<>

{                                                  }   # loop through all letters
 (   {}     [ {} ]<(())>){((<{}{}>))}{}                # equals from the wiki   
                                                       # but first:
  ((  <>))<>                                           # push the top letter on the other 
                                                       # stack twice  
             (  )                                      # push the second letter back on
                                       {        }      # if they were equal:
                                        (<    >)       # push a 0 to exit this loop
                                          {}{}         # after popping the 1 from the 
                                                       # comparison and the next letter
                                                       # (the duplicate)
                                                 {}    # pop the extra 0
                                                    <> # switch stacks

Part 2 (at this point, everything is duplicated in reverse order):
{({}<>)<>}<>

{        }   # for every letter:
 ({}<>)      # move the top letter to the other stack
       <>    # and switch back
          <> # Finally switch stacks and implicitly print

Answer 13

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

Œgs€2ṁ€€2

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

Answer 14

वी 10 बाइट्स

ͨ.©±½/±±

TryItOnline

बस धागे में बाकी सभी की तरह रेगेक्स को ढूंढें और बदलें। एकमात्र अंतर यह है कि मैं किसी भी चीज़ को बदल सकता हूं \जिसके लिए समान ascii मान के साथ चरित्र के सामने एक की आवश्यकता होगी , लेकिन उच्च गुणवत्ता वाला सेट। (तो (, 00101000 बन जाता है ¨, 10101000)

Answer 15

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

s:g/(.)$0?/$0$0/

-p कमांड लाइन स्विच के साथ

उदाहरण:

$ perl6 -pe 's:g/(.)$0?/$0$0/' <<< 'AAABBBCCCCDDDD
> HEY
> AAAAAAA
> N
> OOQQO
> ABBB
> ABBA'
AAAABBBBCCCCDDDD
HHEEYY
AAAAAAAA
NN
OOQQOO
AABBBB
AABBAA

Answer 16

रैकेट 261 बाइट्स

(let((l(string->list s))(r reverse)(c cons)(e even?)(t rest)(i first))(let p((l(t l))(ol(c(i l)'())))
(cond[(empty? l)(list->string(if(e(length ol))(r ol)(r(c(i ol)ol))))][(or(equal?(i ol)(i l))(e(length ol)))
(p(t l)(c(i l)ol))][(p(t l)(c(i l)(c(i ol)ol)))])))

Ungolfed:

(define (f s)
  (let ((l (string->list s)))
    (let loop ((l (rest l))
               (ol (cons (first l) '())))
      (cond
        [(empty? l)
         (list->string(if (even? (length ol))
                          (reverse ol)
                          (reverse (cons (first ol) ol))))]
        [(or (equal? (first ol) (first l)) 
             (even? (length ol)))
         (loop (rest l) (cons (first l) ol))]
        [else
         (loop (rest l) (cons (first l) (cons (first ol) ol)))] ))))

परिक्षण:

(f "ABBBCDDEFFGGG")

आउटपुट:

"AABBBBCCDDEEFFGGGG"

Answer 17

05AB1E , 10 बाइट्स

.¡vy¬ygÉ×J

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

व्याख्या

.¡           # split string into groups of the same char
  v          # for each group
   y         # push the group
    ¬        # push the char the group consists of
     yg      # push the length of the group
       É     # check if the length of the group is odd
        ×    # repeat the char is-odd times (0 or 1)
         J   # join to string

Answer 18

पायथन 3, 102 94 बाइट्स

from collections import*
lambda s:"".join(c*(s.count(c)+1&-2)for c in OrderedDict.fromkeys(s))

8 बाइट बचाने के लिए xnor का धन्यवाद ! -> बिथक।

Comments

यह अक्षरों को सही क्रम में नहीं रखता है।

— xnor

@xnor उल्लेख करने के लिए धन्यवाद! फिक्स्ड।

— यति

अछा लगता है। आप के x+x%2रूप में अभिव्यक्ति लिख सकते हैं x&-2।

— xnor

@xnor मैंने कोशिश की s.count(c)&-2और यह एक खाली स्ट्रिंग लौटा ...: / कोई विचार?

— यति

ओह, तुम सही हो और मैंने एक गलती की है। मुझे लगता है कि x+1&-2यह करना चाहिए। इवेंस खुद के पास जाते हैं और ओड्स को गोल करते हैं।

— xnor

Answer 19

आर, 81 बाइट्स

r=rle(el(strsplit(scan(,""),"")));cat(do.call("rep",list(r$v,r$l+r$l%%2)),sep="")

स्टड से एक स्ट्रिंग पढ़ता है, पात्रों के वेक्टर में घूमता है और रन-लंबाई एन्कोडिंग (आरएलई) करता है। इसके बाद रीले से प्रत्येक मान, लंबाई और लंबाई मॉड का योग दोहराएं 2।

यदि हम अंतरिक्ष द्वारा अलग किए गए इनपुट को पढ़ सकते हैं (स्पष्ट रूप से एक वेक्टर / वर्णों के सरणी के रूप में) तो हम विभाजन भाग को छोड़ सकते हैं और कार्यक्रम 64 बाइट्स तक कम कर सकते हैं:

r=rle(scan(,""));cat(do.call("rep",list(r$v,r$l+r$l%%2)),sep="")

Answer 20

> <> (मछली) 39 बाइट्स

0v ;oo:~/:@@:@=?!voo
 >i:1+?!\|o !:  !<

बहुत यकीन है कि यह एक अलग तकनीक का उपयोग करके बहुत अधिक गोल्फ हो सकता है।

यह एक इनपुट लेता है और वर्तमान स्टैक आइटम के खिलाफ तुलना करता है, यदि यह अलग है तो यह पहले स्टैक आइटम को दो बार प्रिंट करेगा, यदि यह दोनों को प्रिंट करता है।

स्टैक जब खाली हो जाता है तो 0 के साथ आपूर्ति की जाती है जो कुछ भी प्रिंट नहीं करता है जब भी इसे जोड़ा जा सकता है।

Answer 21

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

Vrz8p*+hN%hN2eN

सभी परीक्षण मामलों को यहां सत्यापित करें।

कार्यप्रणाली के लिए लुइस मेंडो का धन्यवाद ।

व्याख्या

Vrz8p*+hN%hN2eN    z autoinitializes to the input
 rz8               run-length encode the input, returned as list of tuples (A -> [[1,"A"]])
V                  for every element N in this list
      +hN          add the head element of N (the number in the tuple)
         %hN2      to the head element of N mod 2
     *       eN    repeat the tail element of N that many times (the letter in the tuple)
    p              print repeated character without trailing newline

जैसा कि अक्सर होता है, मुझे ऐसा लगता है कि यह छोटा हो सकता है। मुझे लगता है कि सूची से तत्वों को निकालने का एक बेहतर तरीका होना चाहिए जो मैं यहां उपयोग कर रहा हूं।

Answer 22

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

$args-replace'(.)\1?','$1$1'

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

पोर्ट ऑफ़ रेटिना उत्तर । ध्यान देने वाली बात यह है कि हम $argsसामान्य के बजाय $args[0]( -replaceइनपुट ऐरे में प्रत्येक आइटम पर पुनरावृति करेंगे, हम इंडेक्स को गॉल्फ़ कर सकते हैं), और '$1$1'एकल कोट्स की जरूरत है ताकि वे रीजिक्स से बदल जाएं चर को PowerShell चर के रूप में माना जा रहा है (जो कि यदि वे दोहरे-उद्धरण हैं तो क्या होगा)।

Answer 23

सी, 67 बाइट्स

i;f(char*s,char*d){i=*s++;*d++=i;*d++=i;*s?f(i-*s?s:++s,d):(*d=0);}

के साथ बुलाना:

int main()
{
    char *in="AAABBBCCCCDDDD";
    char out[128];
    f(in,out);
    puts(out);
}

Answer 24

ब्रेनफक, 22 बाइट्स

,
[
  [>->+<<-]
  >[>..<<]
  >,
]

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

वर्तमान चरित्र को दो बार प्रिंट करता है, जब तक कि यह केवल दो बार मुद्रित होने वाले चरित्र के बराबर न हो।