Nếu một chuỗi T có độ dài K xuất hiện K hoặc nhiều lần hơn trong chuỗi S , thì đó là khả năng mang tính cộng đồng . Ví dụ, 10trong 10/10có khả năng cộng sản, vì nó xuất hiện 2 lần và có độ dài 2 . Lưu ý rằng các chuỗi con không thể chồng lấp.

Một chuyển đổi cộng sản là một trong đó có chuỗi này T và di chuyển mỗi nhân vật t _i của T cho tôi xảy ra T trong S . Vì vậy, đối với ví dụ trước, sự chuyển đổi cộng sản sẽ mang lại 1/0; char đầu tiên 10thay thế 10lần đầu tiên 10được tìm thấy và 0lần thứ hai.

Một bình thường cộng sản là một hàm mang theo tất cả các chuỗi như T với K ≥ 2 và thực hiện một chuyển đổi cộng sản trên chúng.

Một số chi tiết cụ thể về thuật toán:

1. Thực hiện các phép biến đổi cộng sản trên chuỗi hợp lệ dài nhất T trước tiên . Ủng hộ các lần xuất hiện đầu tiên của T .
2. Sau đó, thực hiện các phép biến đổi cộng sản trên các chuỗi dài nhất tiếp theo, sau đó là các chuỗi dài nhất tiếp theo ... vv
3. Lặp lại cho đến khi không có chuỗi như vậy tồn tại trong chuỗi.

Lưu ý rằng một số chuỗi, chẳng hạn như ví dụ "Xin chào, Xin chào" trong các trường hợp thử nghiệm, có thể được hiểu theo hai cách khác nhau. Bạn có thể sử dụng ellcho T , nhưng bạn cũng có thể sử dụng llo. Trong trường hợp này, mã của bạn có thể chọn một trong hai tùy chọn. Trường hợp thử nghiệm được hiển thị sử dụng llo, nhưng bạn có thể nhận được một đầu ra khác nhau và hợp lệ như nhau.

Nhiệm vụ của bạn là thực hiện bình thường hóa cộng sản. Đầu vào sẽ chỉ bao gồm các ký tự ASCII có thể in được (0x20 đến 0x7E, khoảng trắng đến dấu ngã). Bạn có thể viết một chương trình hoặc chức năng để giải quyết nhiệm vụ này; đầu vào có thể được lấy dưới dạng một dòng từ STDIN, đối số mảng chuỗi / ký tự, đối số từ ARGV, v.v.

Các trường hợp thử nghiệm

'123' -> '123'
'111' -> '111'
'1111' -> '11'
'ABAB' -> 'AB'
'111111111' -> '111'
'asdasdasd' -> 'asd'
'10/10' -> '1/0'
'100/100+100' -> '1/0+0'
'   +   +   ' -> ' + '
'Hello, hello, dear fellow!' -> 'Hel he, dear feow!' OR 'Heo hl, dear flow!'
'11122333/11122333/11122333' -> '112/13' OR '132/23'

'ababab1ababab' -> 'a1bab'
'1ab2ab3ab4ab5ab6' -> '1a2b3a4b5ab6'

Làm việc thử nghiệm

Định dạng là 'string', 'substring', ở mỗi bước thay thế. Các bit thay thế được đặt trong ngoặc.

'11[122]333/11[122]333/11[122]333', '122'
'111[333]/112[333]/112[333]', '333'
'1113/11[23]/11[23]', '23'
'11[13]/112/1[13]', '13'
'1[11]/[11]2/13', '11'
'1[/1]12[/1]3', '/1'
'112/13', ''

Một trường hợp thử nghiệm khác:

'Hello, hello, dear fellow!', 'llo'
'Hel, hel, dear feow!', 'l,'
'Hel he, dear feow!', ''

Mã tham chiếu (Python)

Bạn có thể thấy điều này hữu ích để hình dung thuật toán.

#!/usr/bin/env python

import re

def repeater(string):
    def repeating_substring(substring):
        return (string.count(substring) == len(substring)) and string.count(substring) > 1

    return repeating_substring

def get_substrings(string):
    j = 1
    a = set()
    while True:
        for i in range(len(string) - j+1):
            a.add(string[i:i+j])
        if j == len(string):
            break
        j += 1
    return list(a)

def replace_each_instance(string, substring):
    assert `string`+',', `substring`
    for i in substring:
        string = re.sub(re.escape(substring), i, string, 1)

    return string


def main(s):
    repeats = repeater(s)
    repeating_substr = filter(repeater(s), get_substrings(s))

    while repeating_substr:
        repeating_substr.sort(lambda x,y: cmp(len(y), len(x)))
        s = replace_each_instance(s, repeating_substr[0])
        repeating_substr = filter(repeater(s), get_substrings(s))

    return s

assert main('123') == '123'
assert main('111') == '111'
assert main('1111') == '11'
assert main('ABAB') == 'AB'
assert main('111111111') == '111'
assert main('asdasdasd') == 'asd'
assert main('10/10') == '1/0'
assert main('100/100+100') == '1/0+0'
assert main('   +   +   ') == ' + '
assert main('Hello, hello, dear fellow!') == 'Hel he, dear feow!'
assert main('11122333/11122333/11122333') == '112/13'

Cảm ơn @ ConorO'Brien đã đăng ý tưởng ban đầu của thử thách này.

Bình thường, 22 byte

u.xse.iLcGdf>cGTlTt#.:

Bộ kiểm tra

Để thực sự xem chương trình đang làm gì, hãy xem điều này:

Nội bộ

Đặc biệt, chương trình luôn sử dụng thay thế cuối cùng của các thay thế dài nhất.

Giải trình:

u.xse.iLcGdf>cGTlTt#.:
u.xse.iLcGdf>cGTlTt#.:G)GQ    Implicit
u                        Q    Starting with the input, repeat the following
                              until a fixed point is reached.
                    .:G)      Construct all substrings of the current value
                              ordered smallest to largest, front to back.
                  t#          Filter on having more than 1 element.
                              These are the eligible substrings.
           f                  Filter these substrings on
             cGT              Chop the current value on the substring,
            >   lT            Then remove the first len(substring) pieces.
                              The result is nonempty if the substring is
                              one we're looking for. 
                              Chopping gives nonoverlapping occurrences.
     .iL                      Interlace the substrings with
        cGd                   Chop the current value on that substring
   se                         Take the final result, make it a string.
 .x                     G     If there weren't any, the above throws an error,
                              So keep the current value to halt.

JavaScript (ES6), 121 byte

f=(s,j=2,o,m=s.match(`(.{${j}})(.*\\1){${(j-1)}}`))=>m?f(s,j+1,s.split(m[1]).map((e,i)=>e+(m[1][i]||'')).join``):o?f(o):s

Đệ quy phù hợp với mô hình:

(.{2})(.*\1){1}  //2 characters, repeated 1 time 
(.{3})(.*\1){2}  //3 characters, repeated 2 times 
(.{4})(.*\1){3}  //4 characters, repeated 3 times 
etc.

Cho đến khi mô hình không được tìm thấy. (Điều này đảm bảo rằng chuỗi dài nhất được xử lý trước.)

Sau đó, nó thực hiện "các biến đổi cộng đồng" trên mẫu tìm thấy cuối cùng, bằng cách chia nhỏ trên trận đấu và tham gia vào từng nhân vật của trận đấu. ( mapđược sử dụng cho mục đích này. Quá tệ joinkhông thực hiện cuộc gọi lại.)

Cuối cùng nó cũng đệ quy trên chuỗi mới này cho đến khi nó không còn mang tính cộng sản .

Các trường hợp thử nghiệm:

f=(s,j=2,o,m=s.match(`(.{${j}})(.*\\1){${(j-1)}}`))=>m?f(s,j+1,s.split(m[1]).map((e,i)=>e+(m[1][i]||'')).join``):o?f(o):s

console.log(f('123'));  //123
console.log(f('111'));  //111
console.log(f('1111')); //11
console.log(f('ABAB')); //AB
console.log(f('111111111')); //111
console.log(f('asdasdasd')); //asd
console.log(f('10/10')); //1/0
console.log(f('100/100+100')); //1/0+0
console.log(f('   +   +   ')); // + 
console.log(f('Hello, hello, dear fellow!')); //Heo hl, dear flow!
console.log(f('11122333/11122333/11122333')); //132/23

Sạch , 420 ... 368 byte

import StdEnv,StdLib
l=length
%q=any((==)q)
?_[]=[]
?a[(y,x):b]|isPrefixOf a[x:map snd b]=[y: ?a(drop(l a-1)b)]= ?a b
$s=sortBy(\a b=l a>l b)(flatten[[b: $a]\\(a,b)<-map((flip splitAt)s)[0..l s-1]])
f s#i=zip2[0..]s
#r=filter(\b=l(?b i)>=l b&&l b>1)($s)
|r>[]#h=hd r
#t=take(l h)(?h i)
=f[if(%n t)(h!!hd(elemIndices n t))c\\(n,c)<-i|not(%n[u+v\\u<-t,v<-[1..l h-1]])]=s

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