Bu mücadelede size girdi olarak alfabetik bir dize verilecektir. Verilen bir girişin "anti-string" ini, tüm ters çevrilen harflerin olduğu gibi string olarak tanımlayacağız. Örneğin

AaBbbUy -> aAbBBuY

Girdi olarak bir dize alan ve anti-string de bitişik bir alt dize olan en uzun bitişik alt dizgiyi arayan bir program yazmalısınız. İki alt dizgi üst üste binmemelidir.

Örnek olarak size bir dize verildiyse

fAbbAcGfaBBagF

Kalın bölümler en uzun dize anti-string çifti olacaktır.

Programınız çifti bulduktan sonra, her birini tek bir karakter halinde daraltmalıdır. Bunu, her alt dizinin ilk karakteri dışındakileri kaldırarak yapması gerekir. Örneğin yukarıdaki dize

fAbbAcGfaBBagF

olacaktı

fAcGfagF

Ardından, programınız en uzun dize anti-string çifti tek bir karakter veya daha kısa olana kadar işlemi tekrar etmelidir.

Örneğin, aynı dizeyle çalışmak, çökmeden sonraki en uzun yeni çift

fAcGfagF

Böylece tekrar ipi daraltırız.

fAcGag

Şimdi string daha fazla daraltılamaz, bu yüzden onu çıkarmalıyız.

Aday çiftler (örneğin AvaVA) arasında bir bağ olması durumunda, indirim yapabilir ( AaAya da AvVdeğil Aa).

Bu kod-golf'dür, bu nedenle cevaplar daha az byte'ın daha iyi olmasıyla byte olarak puanlanacaktır.

Test Kılıfları

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

Motivasyonları

Bu sorun rastgele görünse de, temel poligonları işlemek için kod yaparken karşılaştığım bir problem. Bu işlem, temel bir poligonu daha küçük n -gona düşürmek için kullanılabilir . Denemeden sonra küçük bir golf yapacağını düşündüm.

Perl, 64 61 bayt

içerir +1içinp

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

JavaScript (ES6), 200 bayt

G / Ç için karakter dizilerini kullanır.

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

Çevrimiçi deneyin!

Retina , 119 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

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

Girişi çoğaltın ve ilk kopyayı çevirin.

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

Anti-string hiç yoksa, çevrilen kopyayı silin.

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

Tüm olası çökmüş dizgileri listeleyin.

N$`
$.&
}0G`

Bunları uzunluk sırasına göre sıralayın, en kısa sürün (yani en uzun anti-string) ve tüm anti-stringler çökene kadar tekrarlayın.

Python 3 , 189 181 bayt

Jonathan Frech'e teşekkür ederek tek kat saf.

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

Çevrimiçi deneyin!

Kendi sürümüm, artık eski (189 bayt):

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

Çevrimiçi deneyin!

any()Yuvalanmış döngüleri erkenden ayırmak set()ve kavramada kullanılabilir değişken global nesne için. Gerisi, kullanan gereksinimlerin sadece basit bir uygulamasıdır str.swapcase.

Python 2,160 bayt

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

Çevrimiçi deneyin!

Düzenli olarak yuvalanmış iç içe geçmişin erken kırılmasının return"zekice" numarasından çok daha kısa olduğu ortaya çıktı any.

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

• İki bayt kaydedildi; bir sokak değişkeni tanımı kaldırıldı.
• Onbir on üç bayt kaydedildi ; golfed b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64için b|=abs(S[p+m]-S[q+m])-32için b|=32-S[p+m]+S[q+m]&63.
• Üç bayt kaydedildi; golfed for(...;...;p++)S[p+1]=S[p+L];için for(...;...;S[++p]=S[p+L]);.
• Ceilingcat sayesinde altı bayt kurtardı .

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

Çevrimiçi deneyin!

Python 2,180 bayt

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

Çevrimiçi deneyin!

Stax , 30 bayt

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

Koş ve hata ayıkla

Aynı programın karşılık gelen ascii gösterimi budur.

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

Bir regex yaklaşımı kullanır. Tekrar tekrar dize değiştirme regex. Bunları mevcut değerin her bitişik alt dizesinden oluşturur. Örneğin girdi fAbbAcGfaBBagFiçin alt dizelerden biri AbbA, bu durumda regex AbbA(.*)aBBaile değiştirilecektir 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

Wolfram Dili (Mathematica) , 148 bayt

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

Çevrimiçi deneyin!

Japt -h , 33 bayt

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

Dene

à ñÊÅÔ£=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