Dành một chút thời gian trên trang web này, tôi đã đến để tận hưởng mọi thứ càng ngắn càng tốt. Đó có thể là lý do tại sao gần đây tôi bị xúc phạm bởi các chuỗi chứa cùng một ký tự nhiều lần. Công việc của bạn là viết một hàm hoặc chương trình ngưng tụ một chuỗi đã cho theo các quy tắc sau:

• Bắt đầu với một ngưng tụ 0 , đó là tìm cặp đầu tiên (ngoài cùng bên trái) của cùng một ký tự với 0 ký tự khác giữa chúng. Nếu tìm thấy một cặp như vậy, loại bỏ một trong hai ký tự và khởi động lại thuật toán bằng cách thực hiện một ngưng tụ 0 khác . Nếu không tìm thấy cặp nào như vậy, hãy tiến hành bước tiếp theo. Ví dụ:
  programming-C0-> programing
aabbcc-C0-> abbcc
test-C0->test

• Sau đó thực hiện ngưng tụ 1 , đó là tìm cặp đầu tiên của cùng một ký tự với 1 ký tự khác giữa chúng. Nếu một cặp như vậy được tìm thấy, loại bỏ một trong số chúng và tất cả các ký tự giữa chúng và khởi động lại với độ ngưng tụ 0 . Nếu không tìm thấy cặp nào như vậy, hãy tiến hành bước tiếp theo. Ví dụ:
  abacac-C1-> acac
java-C1->ja

• Tiếp tục với một ngưng tụ 2 và cứ thế đến một ngưng tụ n với n là độ dài của chuỗi gốc, mỗi lần khởi động lại sau khi ngưng tụ đã loại bỏ một số chữ cái. Ví dụ:
  programing-C2-> praming
abcdafg-C3->afg

Chuỗi kết quả được gọi là ngưng tụ và chứa mỗi ký tự nhiều nhất một lần.

Đầu vào:

Một chuỗi chữ thường của ký tự ascii có thể in được.

Đầu ra:

Các chuỗi ngưng tụ theo các quy tắc trên.

Ví dụ:

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

Ví dụ chi tiết để làm rõ cách thức hoạt động của thuật toán:

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

Cách tiếp cận của bạn không phải thực hiện thuật toán từ phía trên miễn là giải pháp của bạn và thuật toán trả về cùng một đầu ra cho tất cả các đầu vào được phép. Đây là một thách thức mã golf .

Cảm ơn @Linus vì những bình luận hữu ích trong hộp cát!

JavaScript (ES6), 74 byte

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 byte

Điều này sẽ khiến các ngôn ngữ không chơi gôn bị bỏ lại phía sau ...

-1 $-[0]cảm ơn Riley

-1 @{-}cảm ơn Dada

Bao gồm +1 cho -p

Cung cấp đầu vào trên STDIN

condense.pl:

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

Phiên bản 27 byte này sẽ hoạt động nhưng không phải vì perl không nội suy @-trong regex (xem /programming/39521060/why-are-etc-not-interpiated-in-strings )

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

CJam , 35 byte

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

Hãy thử trực tuyến!

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

Bạn có thể thấy sự ngưng tụ riêng lẻ bằng cách chèned

Python 2, 117 104 101 byte

Đệ quy làm thay thế cần thiết. Tôi xây dựng regex một cách linh hoạt.

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)

Dùng thử trực tuyến

Perl 53 52

Bao gồm +1 cho -p

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

Hãy thử nó trên ideone .

Toán học, 101 byte

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

Cần có một cách để làm cho nó ngắn hơn ...

PHP, 90 byte

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

hoặc 92 byte

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

Ruby, 75 64 57 byte

(56 byte mã + ptùy chọn dòng lệnh.)

Sử dụng phép nội suy chuỗi bên trong regex để kiểm soát độ dài của các trận đấu được thay thế.

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

Kiểm tra:

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

Haskell , 97 88 byte

(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

Hãy thử trực tuyến!

Bersion 97 byte cũ:

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

Hãy thử nó trên ideone .

Giải trình:

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

Các (!)chức năng thực hiện một n-ngưng tụ khi đưa ra một chuỗi một lần toàn bộ và một lần với các nhân vật n đầu tiên loại bỏ, ví dụ abcdbevà cdbecho một 2-ngưng tụ, bởi đệ quy so sánh hai nhân vật hàng đầu.

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