ในการท้าทายนี้คุณจะได้รับสตริงตัวอักษรเป็นอินพุต เราจะกำหนด "anti-string" ของอินพุตที่กำหนดให้เป็นสตริงที่มีกรณีของตัวอักษรทั้งหมดคว่ำ ตัวอย่างเช่น

AaBbbUy -> aAbBBuY

คุณควรเขียนโปรแกรมที่รับสตริงเป็นอินพุตและค้นหาสตริงย่อยที่ต่อเนื่องกันที่ยาวที่สุดซึ่งมีแอนตีสตริงนั้นเป็นสตริงย่อยที่ต่อเนื่องกัน สตริงย่อยทั้งสองไม่ควรทับซ้อนกัน

ตัวอย่างเช่นถ้าคุณได้รับสตริง

fAbbAcGfaBBagF

ส่วนที่เป็นตัวหนาจะเป็นคู่ที่ต่อต้านสตริงที่ยาวที่สุด

โปรแกรมของคุณควรเมื่อพบคู่แล้วยุบให้เป็นอักขระเดียว มันควรทำโดยการลบทั้งหมดยกเว้นตัวอักษรตัวแรกของแต่ละซับสตริง ตัวอย่างเช่นสตริงด้านบน

fAbbAcGfaBBagF

จะกลายเป็น

fAcGfagF

โปรแกรมของคุณควรทำกระบวนการซ้ำจนกว่าคู่ anti-string สตริงที่ยาวที่สุดคืออักขระตัวเดียวหรือสั้นกว่า

ตัวอย่างเช่นการทำงานกับสตริงเดียวกันคู่ที่ยาวที่สุดใหม่หลังจากการล่มสลายคือ

fAcGfagF

ดังนั้นเราจึงยุบสายอีกครั้ง

fAcGag

ตอนนี้สตริงไม่สามารถยุบได้อีกดังนั้นเราควรเอาท์พุท

ในกรณีที่มีการเสมอกันระหว่างคู่ของผู้สมัคร (ตัวอย่างAvaVA) คุณอาจทำการลดขนาด ( AaAหรือAvVแต่ไม่ใช่Aa)

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์ที่น้อยกว่าจะดีกว่า

กรณีทดสอบ

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

แรงจูงใจ

ในขณะที่ปัญหานี้อาจดูเหมือนว่าเป็นเรื่องจริง แต่เป็นปัญหาที่ฉันพบขณะทำโค้ดเพื่อประมวลผลรูปหลายเหลี่ยมพื้นฐาน กระบวนการนี้สามารถใช้เพื่อลดรูปหลายเหลี่ยมพื้นฐานให้มีขนาดเล็กลงn -gon หลังจากที่ฉันลองฉันคิดว่ามันจะทำให้เป็นสนามกอล์ฟเล็ก ๆ ที่ดี

Perl, 64 61 ไบต์

รวม+1สำหรับp

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

JavaScript (ES6), 200 ไบต์

ใช้อาร์เรย์ของอักขระสำหรับ 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

ลองออนไลน์!

เรติน่า 119 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

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

ทำสำเนาอินพุตและพลิกเคสของสำเนาแรก

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

หากไม่มีแอนตี้ - สตริงเลยให้ลบสำเนาที่พลิก

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

แสดงรายการต่อต้าน - สตริงที่เป็นไปได้ที่ยุบได้

N$`
$.&
}0G`

เรียงลำดับตามความยาวใช้เวลาสั้นที่สุด (เช่นแอนตี้ - สตริงที่ยาวที่สุด) และทำซ้ำจนกว่าแอนตี้ - สตริงทั้งหมดจะถูกยุบ

Python 3 , 189 181 ไบต์

ขอมอบเครดิตให้แก่ Jonathan Frech เพื่อทำให้เป็นหนึ่งซับ

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

ลองออนไลน์!

รุ่นของฉันตอนนี้ล้าสมัยแล้ว (189 ไบต์):

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

ลองออนไลน์!

any()เพื่อแยกลูปซ้อนกัน แต่เนิ่น ๆ และset()สำหรับวัตถุระดับโลกที่ไม่แน่นอนที่สามารถใช้งานได้ในความเข้าใจ str.swapcaseส่วนที่เหลือเป็นเพียงการดำเนินการตรงไปตรงมาของความต้องการใช้

Python 2 , 160 ไบต์

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

ลองออนไลน์!

ปรากฎว่าปกติซ้อนกันสำหรับวงที่มีการทำลายต้นผ่านreturnเป็นวิธีสั้นกว่าเคล็ดลับ "ฉลาด" anyกับ

C (gcc) , 240 238 227 225 222 216 ไบต์

• บันทึกสองไบต์ ลบนิยามตัวแปรเร่ร่อน
• บันทึกสิบเอ็ดสิบสามไบต์; แข็งแรงเล่นกอล์ฟb|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64ที่จะไปb|=abs(S[p+m]-S[q+m])-32b|=32-S[p+m]+S[q+m]&63
• บันทึกสามไบต์ แข็งแรงเล่นกอล์ฟไปfor(...;...;p++)S[p+1]=S[p+L];for(...;...;S[++p]=S[p+L]);
• ที่บันทึกไว้หกไบต์ขอบคุณที่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;}

ลองออนไลน์!

Python 2 , 180 ไบต์

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

ลองออนไลน์!

Stax , 30 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

การแสดง ascii ที่สอดคล้องกันของโปรแกรมเดียวกันคือสิ่งนี้

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

มันใช้วิธีการ regex มันเปลี่ยนสตริง regex ซ้ำ ๆ มันสร้างสิ่งเหล่านี้จากแต่ละสตริงย่อยที่ต่อเนื่องกันของค่าปัจจุบัน ยกตัวอย่างเช่นสำหรับการป้อนข้อมูลที่fAbbAcGfaBBagFเป็นหนึ่งในสตริงคือAbbAในกรณีที่ regex ไม่จะถูกแทนที่ด้วยAbbA(.*)aBBaA$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 (Mathematica) , 148 ไบต์

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

ลองออนไลน์!

Japt -h , 33 ไบต์

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

ลองมัน

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