Bu sitede biraz zaman geçirdikten sonra olayların mümkün olduğunca kısa olmasını sağlamaya başladım. Son zamanlarda, aynı karakterleri birden fazla defa içeren dizgilerden rahatsız olduğum için bu olabilir. Senin işin bir işlev veya program yazmaktır yoğunlaşır aşağıdaki kurallara göre belirli bir dize:

• 0 yoğunlaştırma ile başlayın , bu, aralarında 0 karakter bulunan aynı karakterlerin ilk (en soldaki) çiftini arar. Eğer böyle bir çift bulunursa, iki karakterden birini kaldırın ve başka bir 0-yoğunlaştırma gerçekleştirerek algoritmayı yeniden başlatın . Eğer böyle bir çift bulunmazsa, bir sonraki adıma geçin. Örnekler:
  programming-C0-> programing
aabbcc-C0-> abbcc
test-C0->test

• Ardından 1 yoğunlaştırma yapın ; bu, aralarında 1 karakter daha bulunan aynı karakterin ilk çiftini arar. Böyle bir çift bulunursa, onlardan birini ve aralarındaki tüm karakterleri kaldırın ve 0 yoğunlaştırma ile yeniden başlayın . Eğer böyle bir çift bulunmazsa, bir sonraki adıma geçin. Örnekler:
  abacac-C1-> acac
java-C1->ja

• Bir devam 2-yoğunlaşma ve böylece için yukarı n-yoğunlaşma ile n orijinal dize uzunluğu olan bir yoğunlaşma sonra yeniden başlatmayı her zaman bazı harfler kaldırıldı. Örnekler:
  programing-C2-> -C3- praming
abcdafg>afg

Elde edilen dizgeye yoğun olarak adlandırılır ve her bir karakteri en çok bir defa içerir.

Giriş:

Yazdırılabilir ascii karakterlerinden oluşan küçük bir dize.

Çıktı:

Yoğunlaştırılmış yukarıdaki kurallara göre dize.

Örnekler:

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

Algoritmanın nasıl çalıştığını açıklamak için ayrıntılı örnekler:

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

Yaklaşımınız, çözümünüz ve algoritma izin verilen tüm girdiler için aynı çıktıyı döndürdüğü sürece algoritmayı yukarıdan uygulamak zorunda değildir. Bu bir kod golf mücadelesi.

Yardımcı sanal alan yorumları için @Linus'a teşekkür ederiz !

JavaScript (ES6), 74 bayt

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>

Perl, 38 31 30 29 bayt

Bu, golf oynamayan dilleri çok geride bırakmalı ...

Riley$-[0] sayesinde -1

Dada@{-} sayesinde -1

İçin +1 içerir -p

STDIN'e giriş ver

condense.pl:

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

Bu 27 baytlık sürüm çalışmalıdır ancak perl'in @-regex içine enterpolasyon yapmaması nedeniyle çalışmaz (bkz. Https://stackoverflow.com/questions/39521060/why-are-etc-not-interpolated-in-strings )

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

CJam , 35 bayt

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

Çevrimiçi deneyin!

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

Bireysel yoğunlaşmaları yerleştirerek görebilirsiniz.ed

Python 2, 117 104 101 bayt

Tekrarlı olarak gerekli değişiklikleri yapın. Regex'i dinamik olarak yapıyorum.

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)

Çevrimiçi deneyin

Perl 53 52

-P için +1 içerir

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

Ideone üzerinde deneyin .

Mathematica, 101 bayt

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

Bunu kısaltmanın bir yolu olmalı ...

PHP, 90 Bayt

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

veya 92 Bayt

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

Ruby, 75 64 57 bayt

(56 bayt kod + pkomut satırı seçeneği.)

Değiştirilen eşleşmelerin uzunluğunu kontrol etmek için bir regex içinde dize enterpolasyonu kullanma.

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

Ölçek:

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

Haskell , 97 88 bayt

(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

Çevrimiçi deneyin!

Eski 97 byte bersiyon:

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

İdeone üzerinde deneyin .

Açıklama:

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

(!)İşlevi gören bir n-yoğunlaştırma zaman bütün bir kez ve bir kez, örneğin uzaklaştırıldı İlk n karakteri, bir dizge abcdbeve cdbeyinelemeli önde gelen iki karakter karşılaştırarak, bir 2-yoğunlaştırma için.

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