У цьому виклику вам буде надано алфавітний рядок як вхідний текст. Ми визначимо "анти-рядок" даного входу як рядок із регістром усіх перетворених літер. Наприклад

AaBbbUy -> aAbBBuY

Вам слід написати програму, яка приймає рядок як вхідний і шукає найдовшу суміжну підрядку, антиструповий рядок якої також є суміжною підрядкою. Дві підрядки не повинні перетинатися.

Як приклад, якщо вам дали рядок

fAbbAcGfaBBagF

Жирними ділянками була б найдовша анти струнна пара.

Після виявлення пари ваша програма повинна згорнути їх в один символ. Це слід зробити, видаливши всі, крім першого символу кожної підрядки. Наприклад рядок вище

fAbbAcGfaBBagF

став би

fAcGfagF

Потім ваша програма повинна повторювати процес, поки найдовша антиструтна пара не буде однозначною чи коротшою.

Наприклад, для роботи з тією ж строкою нова довга пара після краху

fAcGfagF

Тож ми знову згортаємо рядок

fAcGag

Тепер рядок не можна згортати далі, тому нам слід вивести його.

У разі розриву між парами-кандидатами (приклад AvaVA) ви можете зробити зменшення ( AaAабо AvV, але ні Aa).

Це кодовий гольф, тому відповіді будуть набрані в байтах, а менша кількість байтів буде кращою.

Випробування

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

Мотивації

Хоча ця проблема може здатися довільною, це насправді проблема, з якою я стикався під час створення коду для обробки основних багатокутників. Цей процес може бути використаний для зведення основного многокутника до меншого n -гона. Після того як я спробував це, я подумав, що це зробить хороший маленький гольф.

Perl, 64 61 байт

Включає +1дляp

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

JavaScript (ES6), 200 байт

Використовує масиви символів для вводу / виводу.

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`

Сортуйте їх за порядком довжини, візьміть найкоротший (тобто найдовший анти-струнний) і повторіть, поки всі анти-рядки не будуть згорнуті.

Пітон 3 , 189 181 байт

Подяка Джонатану Фреху за те, що він став чистим однолінійним.

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 байт

• Збережено два байти; видалено визначену змінну визначення.
• Збережено одинадцять тринадцять байт; golfed b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64до b|=abs(S[p+m]-S[q+m])-32до b|=32-S[p+m]+S[q+m]&63.
• Збережено три байти; гольф for(...;...;p++)S[p+1]=S[p+L];до for(...;...;S[++p]=S[p+L]);.
• Збережено шість байтів завдяки плафоні .

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

Спробуйте в Інтернеті!

Стакс , 30 байт

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

Запустіть і налагоджуйте його

Відповідне представлення такої ж програми ascii.

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

Він використовує регулярний підхід. Це неодноразово замінює рядок. Він будує їх з кожної суміжної підрядки поточного значення. Наприклад, для введення є fAbbAcGfaBBagFодна з підрядків AbbA, в цьому випадку регулярний вимір AbbA(.*)aBBaбуде замінено на 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

Мова Вольфрама (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