Giriş

Aşağıdaki dizgeyi izleyelim:

AABBCCDDEFFGG

Mektup hariç, her harfin kopyalandığını görebilirsiniz E. Mektup demek olduğunu That Eolmuştur çoğaltılamaz de- . Bu yüzden, burada yapmamız gereken tek şey, bize şu çoğaltılmamış dizgiyi veren bu işlemi tersine çevirmek.

AABBCCDDEEFFGG

Daha sert bir örnek alalım:

AAAABBBCCCCDD

Eşitsiz sayıda ardışık sayı olduğunu görebilirsiniz B, bu da bir tanesinin BBorijinal diziden kopyalandığı anlamına gelir . Bize veren bu mektubun çoğaltmasını kaldırmamız gerekiyor:

AAAABBBBCCCCDD

Meydan okuma

Yalnızca alfabetik karakterlerden oluşan (yalnızca büyük veya yalnızca küçük harflerden oluşan) boş olmayan bir yinelenen dize verildiğinde , çoğaltılmamış dizeyi döndürür. Dize her zaman en az bir tane yinelenen karakterin geleceğini varsayabilirsiniz.

Test durumları

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

Bu kod golf , yani bayt cinsinden en kısa geçerli gönderim kazanıyor!

MATL , 7 bayt

Y'to+Y"

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

En alalım 'ABBA'örnek girdi olarak.

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'

Retina , 11 bayt

(.)\1?
$1$1

Çevrimiçi deneyin - tüm test durumlarını içerir

Perl, 16 bayt

15 bayt kodu + -pbayrak.

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

Çalıştırmak için:

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

Haskell, 36 bayt

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

Kullanım örneği: u "OOQQO"-> "OOQQOO".

Dize en az 2 öğe içeriyorsa, ilk önce iki kopya alın ve bir tekrarlı arama ekleyin.

• ikinci eleman ve ilk iki eleman farklıysa geri kalanı veya
• sadece gerisi

İkiden daha az eleman varsa (bir veya sıfır), listenin iki kopyasını alın.

Brachylog , 17 bayt

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

Çevrimiçi deneyin!

açıklama

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)

Ruby, 21 bayt

20 bayt artı -pbayrak.

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

JavaScript (ES6), 37 30 bayt

Çok daha verimli olan '$ 1 $ 1' gibi daha verimli kullanarak 7 bayt kurtardı ] [answer] kurtardı

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

Test durumları

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

Mathematica, 41 bayt

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

Bir dizgeye giriş yapan ve bir dizge çıktısı veren adsız işlev. Tamamen veri tekilleştirin, ardından tamamen düzensiz hale getirin. Çok kısa değil, ama şimdilik daha iyisini yapamadım.

Befunge 98 , 24 bayt

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

Çevrimiçi Deneyin!

$ile kolayca değiştirilebilir -ve 2. @ile; .

Sanırım bu, -her ikisinin de -,(veya $,üstü) ve başlangıcından dolayı daha fazla golf oynayabileceğini düşünüyor -\,.

Nasıl?

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.

Java 7, 58 bayt

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

Ungolfed:

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

Test kodu:

Burada dene.

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"));
  }
}

Çıktı:

AABBCCDDEEFFGG
AAAABBBBCCCCDD
AAAABBBBCCCCDDDD
HHEEYY
AAAAAAAA
NN
OOQQOO
AABBBB
AABBAA

PHP, 65 bayt, düzenli ifade yok

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

komut satırı argümanından girdi alır. İle koş -r.

regex? PHP'de çoğu cevap tarafından kullanılan regex her karakteri kopyalar. 44 bayt olurdu:

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

Beyin Flak 69 Bayt

İçin +3 içerir -c

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

Çevrimiçi Deneyin!

Açıklama:

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

Jöle , 9 bayt

Œgs€2ṁ€€2

Çevrimiçi deneyin!

V 10 bayt

ͨ.©±½/±±

TryItOnline

Sadece bir iplik bul ve geri kalanı gibi tüm regex değiştirin. Tek fark, \önünde gerektirecek olan her şeyi aynı ascii değerine sahip karakterle değiştirebilmemdir, ancak yüksek bit ayarıdır. (Yani (, 00101000, 10101000 olur ¨)

Perl 6 , 17 bayt

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

-p ile komut satırı anahtarı

Örnek:

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

Raket 261 bayt

(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)))] ))))

Test yapmak:

(f "ABBBCDDEFFGGG")

Çıktı:

"AABBBBCCDDEEFFGGGG"

05AB1E , 10 bayt

.¡vy¬ygÉ×J

Çevrimiçi deneyin!

açıklama

.¡           # 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

Python3, 102 94 bayt

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

8 byte kaydettiğin için xnor'a teşekkürler ! -> bithack.

R, 81 bayt

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

Stdin'den dize okur, karakterlerin vektörüne dönüşür ve çalışma boyu kodlaması yapar (rle). Daha sonra her bir değeri rle, uzunlukların toplamı ve uzunluklar modundan tekrarlayın.2 .

Boşlukla ayrılmış girişi okuyabilirsek (dolaylı olarak bir vektör / karakter dizisi olarak) o zaman bölme kısmını atlayabiliriz ve program 64 bayta düşer:

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

> <> (Balık) 39 bayt

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

Bunun farklı bir teknik kullanarak çok golf oynayabileceğinden eminim.

Bir girdi alır ve geçerli yığın öğesiyle karşılaştırır, eğer farklıysa, ilk yığın öğesini iki kez basar, aynı ikisi de yazdırılırsa.

Boş olan yığın, hiçbir şey basmayan 0 ile beslenir, böylece ne zaman eklenebilir.

Pyth, 15 bayt

Vrz8p*+hN%hN2eN

Tüm test durumlarını burada doğrulayın.

Luis Mendo'ya teşekkürlerMetodoloji .

açıklama

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

Çoğu zaman olduğu gibi, bunun daha kısa olabileceğini düşünüyorum. Listeden eleman çıkarmanın burada kullandıklarımdan daha iyi bir yolu olması gerektiğini düşünüyorum.

PowerShell , 28 bayt

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

Çevrimiçi deneyin!(tüm test durumlarını içerir)

Retina Limanı cevabını verdi . Tek not noktaları $args, her zamanki yerine sahip olduğumuzdur $args[0]( -replacegiriş dizisindeki her bir öğe üzerinde yineleme yapacağından, dizini iptal edebiliriz) ve '$1$1'tek tırnak işareti olması gerekir, böylece regex ile değiştirilirler. PowerShell değişkenleri olarak değerlendirilmek yerine değişkenler (çift tırnaklılarsa olur).

C, 67 bayt

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

İle ara:

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

brainfuck, 22 bayt

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

Çevrimiçi deneyin.

İki kez basılmış bir karaktere eşit olmadıkça, geçerli karakteri iki kez yazdırır.