Dalam tantangan ini, Anda akan diberikan string alfabet sebagai input. Kami akan mendefinisikan "anti-string" dari input yang diberikan menjadi string dengan huruf semua huruf terbalik. Sebagai contoh

AaBbbUy -> aAbBBuY

Anda harus menulis sebuah program yang mengambil string sebagai input dan mencari substring bersebelahan terpanjang yang anti-stringnya juga substring yang berdekatan. Dua substring tidak harus tumpang tindih.

Sebagai contoh jika Anda diberi string

fAbbAcGfaBBagF

Bagian yang dicetak tebal akan menjadi pasangan string anti-string terpanjang.

Program Anda harus, setelah menemukan pasangan, pisahkan mereka masing-masing menjadi satu karakter. Ini harus dilakukan dengan menghapus semua kecuali karakter pertama dari setiap substring. Misalnya string di atas

fAbbAcGfaBBagF

akan menjadi

fAcGfagF

Program Anda kemudian harus mengulangi proses tersebut hingga pasangan string anti-string terpanjang adalah satu karakter atau lebih pendek.

Misalnya bekerja dengan string yang sama, pasangan terpanjang baru setelah keruntuhan

fAcGfagF

Jadi kami kembali menutup string

fAcGag

Sekarang string tidak dapat diciutkan lebih lanjut sehingga kita harus menampilkannya.

Dalam kasus ikatan antara pasangan kandidat (contoh AvaVA) Anda dapat melakukan pengurangan ( AaAatau AvV, tetapi tidak Aa).

Ini adalah kode-golf sehingga jawaban akan dicetak dalam byte dengan lebih sedikit byte yang lebih baik.

Uji Kasus

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

Motivasi

Sementara masalah ini mungkin tampak sewenang-wenang itu sebenarnya masalah yang saya temui saat membuat kode untuk memproses poligon mendasar. Proses ini dapat digunakan untuk mengurangi poligon dasar menjadi n- gon yang lebih kecil . Setelah saya mencobanya saya pikir itu akan membuat golf kecil yang menyenangkan.

Perl, 64 61 byte

Termasuk +1untukp

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

JavaScript (ES6), 200 byte

Menggunakan array karakter untuk 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

Cobalah online!

Retina , 119 byte

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

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

Gandakan input dan balikkan kasus salinan pertama.

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

Jika tidak ada anti-string sama sekali maka hapus duplikat terbalik.

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

Daftar semua kemungkinan anti-string yang diciutkan.

N$`
$.&
}0G`

Urutkan sesuai urutan panjangnya, ambil yang terpendek (yaitu anti-string terpanjang), dan ulangi sampai semua anti-string telah runtuh.

Python 3 , 189 181 byte

Penghargaan untuk Jonathan Frech karena membuatnya murni satu garis.

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

Cobalah online!

Versi saya sendiri, sekarang sudah usang (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

Cobalah online!

any()untuk memecahkan loop bersarang lebih awal, dan set()untuk objek global yang dapat berubah dapat digunakan dalam pemahaman. Sisanya hanyalah implementasi langsung dari persyaratan menggunakan 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

Cobalah online!

Ternyata bahwa nested reguler untuk loop dengan menerobos lebih awal returnjauh lebih pendek daripada trik "pintar" any.

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

• Disimpan dua byte; menghapus definisi variabel liar.
• Disimpan sebelas tiga belas byte; golfed b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64untuk b|=abs(S[p+m]-S[q+m])-32ke b|=32-S[p+m]+S[q+m]&63.
• Disimpan tiga byte; bermain golf for(...;...;p++)S[p+1]=S[p+L];untuk for(...;...;S[++p]=S[p+L]);.
• Disimpan enam byte berkat ceilingcat .

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

Cobalah online!

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

Cobalah online!

Stax , 30 byte

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

Jalankan dan debug itu

Representasi ascii yang sesuai dari program yang sama adalah ini.

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

Itu menggunakan pendekatan regex. Itu berulang kali regex penggantian string. Itu membangun ini dari setiap substring yang berdekatan dari nilai saat ini. Misalnya untuk input fAbbAcGfaBBagF, salah satu substring adalah AbbA, dalam hal ini regex AbbA(.*)aBBaakan diganti 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

Bahasa Wolfram (Mathematica) , 148 byte

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

Cobalah online!

Japt -h , 33 byte

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

Cobalah

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