Trong thử thách này, bạn sẽ được cung cấp một chuỗi chữ cái làm đầu vào. Chúng tôi sẽ định nghĩa "chống chuỗi" của một đầu vào đã cho là chuỗi với trường hợp tất cả các chữ cái được đảo ngược. Ví dụ

AaBbbUy -> aAbBBuY

Bạn nên viết một chương trình lấy một chuỗi làm đầu vào và tìm kiếm chuỗi con liền kề dài nhất có chuỗi chống cũng là một chuỗi con liền kề. Hai chất nền không được chồng lên nhau.

Ví dụ nếu bạn được cung cấp chuỗi

fAbbAcGfaBBagF

Các phần được in đậm sẽ là cặp chống chuỗi dài nhất.

Chương trình của bạn nên, một khi nó đã tìm thấy cặp, thu gọn chúng thành một ký tự duy nhất. Nó nên làm điều này bằng cách loại bỏ tất cả trừ ký tự đầu tiên của mỗi chuỗi con. Ví dụ chuỗi trên

fAbbAcGfaBBagF

sẽ trở thành

fAcGfagF

Chương trình của bạn sau đó sẽ lặp lại quy trình cho đến khi cặp chống chuỗi dài nhất là một ký tự đơn hoặc ngắn hơn.

Ví dụ: làm việc với cùng một chuỗi, cặp dài nhất mới sau khi thu gọn là

fAcGfagF

Vì vậy, chúng tôi thu gọn chuỗi một lần nữa

fAcGag

Bây giờ chuỗi không thể được thu gọn hơn nữa vì vậy chúng ta nên xuất nó.

Trong trường hợp hòa giữa các cặp ứng cử viên (ví dụ AvaVA), bạn có thể thực hiện giảm ( AaAhoặc AvV, nhưng không Aa).

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

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

fAbbAcGfaBBagF  ->  fAcGag
AvaVA ->  AaA / AvV
QQQQQQQ -> QQQQQQQ
fAbbAcQQQQaBBacqqqqA -> fAbcQBcq
gaq -> gaq
fAbbAcGfaBBagFaBBa -> fcGaBBag

Động lực

Mặc dù vấn đề này có vẻ tùy tiện nhưng nó thực sự là một vấn đề tôi gặp phải trong khi tạo mã để xử lý các đa giác cơ bản. Quá trình này có thể được sử dụng để giảm đa giác cơ bản thành đa giác n nhỏ hơn . Sau khi tôi thử nó, tôi nghĩ rằng nó sẽ tạo ra một sân golf nhỏ.

Perl, 64 61 byte

Bao gồm +1chop

perl -pE 's/(.\K.{$%})(.*)(?=(.))(??{$1^$"x$%.$"})/$2$3/ while$%=--pos' <<< fAbbAcGfaBBagFaBBa

JavaScript (ES6), 200 byte

Sử dụng mảng ký tự cho I / O.

f=a=>(m=M=C=>a.map((_,i)=>a.map((_,j)=>C(i,j-i+1))))(I=>M((i,j)=>a.slice(i,i+j).some((n,k)=>n[c='charCodeAt']()^(a[I+k]||'')[c]()^32)|I+j>i|j<m||(x=[i,I],m=j)))&&m-->1?f(a,x.map(p=>a.splice(p+1,m))):a

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

Võng mạc , 119 byte

.+
$&¶$&
T`Ll`lL`.*¶
/(.).*¶.*\1/^&0A`
¶&Lv$`(?<=(.)*)((.)(.)*).*¶(?>((?<-1>.)*.)(?<-4>.)*)(.*)\2
$5$6$3$'
N$`
$.&
}0G`

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

.+
$&¶$&
T`Ll`lL`.*¶

Sao chép đầu vào và lật trường hợp của bản sao đầu tiên.

/(.).*¶.*\1/^&0A`

Nếu không có chuỗi chống nào cả thì hãy xóa bản sao bị lật.

¶&Lv$`(?<=(.)*)((.)(.)*).*¶(?>((?<-1>.)*.)(?<-4>.)*)(.*)\2
$5$6$3$'

Liệt kê tất cả các chuỗi chống sập có thể.

N$`
$.&
}0G`

Sắp xếp chúng theo thứ tự độ dài, lấy đoạn ngắn nhất (tức là chuỗi chống dài nhất) và lặp lại cho đến khi tất cả các chuỗi chống được thu gọn.

Python 3 , 189 181 byte

Tín dụng cho Jonathan Frech để làm cho nó một lớp lót tinh khiết.

f=lambda s,x=set():any(u in s[j+i:]and(x.add(s[:j+1]+s[j+i:].replace(u,u[0],1))or 1)for i in range(len(s),1,-1)for j in range(len(s))for u in[s[j:j+i].swapcase()])and f(x.pop())or s

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

Phiên bản của riêng tôi, hiện đã lỗi thời (189 byte):

x=set()
def f(s):
 while any(u in s[j+i:]and(x.add(s[:j+1]+s[j+i:].replace(u,u[0],1))or 1)for i in range(len(s),1,-1)for j in range(len(s))for u in[s[j:j+i].swapcase()]):s=x.pop()
 return s

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

any()để sớm thoát ra khỏi các vòng lặp lồng nhau và set()cho đối tượng toàn cầu có thể thay đổi có thể sử dụng được trong việc hiểu. Phần còn lại chỉ là việc thực hiện đơn giản các yêu cầu sử dụng str.swapcase.

Python 2 , 160 byte

def f(s):
 for i in range(len(s),1,-1):
	for j in range(len(s)):
	 u=s[j:j+i].swapcase()
	 if u in s[j+i:]:return f(s[:j+1]+s[j+i:].replace(u,u[0],1))
 return s

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

Hóa ra rằng vòng lặp lồng nhau thường xuyên với đột phá sớm returnlà cách ngắn hơn so với thủ thuật "thông minh" với any.

C (gcc) , 240 238 227 225 222 216 byte

• Lưu hai byte; loại bỏ một định nghĩa biến đi lạc.
• Đã lưu mười một mười ba byte; golfed b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64để b|=abs(S[p+m]-S[q+m])-32đến b|=32-S[p+m]+S[q+m]&63.
• Đã lưu ba byte; golfed for(...;...;p++)S[p+1]=S[p+L];tới for(...;...;S[++p]=S[p+L]);.
• Đã lưu sáu byte nhờ trần .

p,P,q,Q,l,L,b,m;f(char*S){for(p=0;S[p];p++)for(l=0;S[l+++p];)for(q=0;b=S[q+~-l];!b&p+l<=q&l>L?L=l,P=p,Q=q:0,q++)for(b=0,m=l;m--;)b|=32-S[p+m]+S[q+m]&63;for(;b-2;)for(p=b++?-~Q-L:P;S[p];S[++p]=S[L+p]);~-L?L=0,f(S):0;}

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

Python 2 , 180 byte

def f(s):
 L=len(s)
 for x,y in[(i,i+j)for j in range(L,1,-1)for i in range(L-j)]:
	t=s[x:y];T=t.swapcase()
	if T in s[y:]:return f(s.replace(t,t[0],1).replace(T,T[0],1))
 return s

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

Stax , 30 byte

î☼fúΩ§☺æ╒ºê@Ñ▀'╫Iqa{d]∟Sa5♦⌂─╚

Chạy và gỡ lỗi nó

Đại diện ascii tương ứng của cùng một chương trình là đây.

c%Dc:e{%orF..*:{_{32|^mY++_h.$1yh++R

Nó sử dụng một cách tiếp cận regex. Nó liên tục thay thế chuỗi regex. Nó xây dựng những thứ này từ mỗi chuỗi con liền kề của giá trị hiện tại. Ví dụ cho đầu vào fAbbAcGfaBBagF, một trong các chuỗi con là AbbA, trong trường hợp đó, biểu thức chính quy AbbA(.*)aBBasẽ được thay thế bằng A$1a.

c                                       get number of characters
 %D                                     repeat rest of program that many times
   c:e                                  get all substrings
      {%or                              order substrings longest to shortest
          F                             for each substring, execute the rest
           ..*:{                        build the string "(.*)"
                _{32|^m                 current substring with case inverted
                       Y                save the inverted case in register y
                        ++              concatenate search regex together
                                            e.g. "aBc(.*)AbC"
                          _h            first character of substring
                            .$1         "$1"
                               yh       first character of inverted case
                                 ++     concatenate replacement regex together
                                            e.g. "a$1A"
                                   R    do regex replacement

Ngôn ngữ Wolfram (Mathicala) , 148 byte

#//.s_:>MinimalBy[StringReplaceList[s,a:(p_~~__)~~x___~~b:(q_~~__)/;(32==##&@@Abs[(t=ToCharacterCode)@a-t@b]):>p<>x<>q]/.{}->{s},StringLength][[1]]&

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

Japt -h , 33 byte

à ñÊÅÔ£=rX+"(.*)"+Xc^H ÈÎ+Y+XÎc^H

Thử nó

à ñÊÅÔ£=rX+"(.*)"+Xc^H ÈÎ+Y+XÎc^H     :Implicit input of string U
à                                     :Combinations
  ñ                                   :Sort by
   Ê                                  :  Length
    Å                                 :Remove first element (the empty string)
     Ô                                :Reverse
      £                               :Map each X
       =                              :  Reassign to U
        r                             :  Global replacement
         X+"(.*)"+                    :  Append "(.*)" to X and then append
                  Xc                  :    Charcodes of X
                    ^H                :    XORed with 32
                      È               :  Pass each match X, with captured group Y, through the following function
                       Î+Y+           :    Append Y to the first character of X and then append
                           XÎc^H      :      The charcode of the first character of X XORed with 32