이 도전에서 당신은 입력으로 알파벳 문자열이 제공됩니다. 우리는 주어진 입력의 "안티 문자열"을 모든 문자의 대소 문자가 반전 된 문자열로 정의 할 것입니다. 예를 들어

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- 곤 으로 줄이는 데 사용할 수 있습니다 . 내가 그것을 시도한 후 나는 그것이 좋은 작은 골프를 만들 것이라고 생각했다.

펄, 64 61 바이트

포함 +1을 위해p

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

자바 스크립트 (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`

길이 순서대로 정렬하고, 가장 짧은 (즉, 가장 긴 안티 스트링) 취한 후 모든 안티 스트링이 무너질 때까지 반복하십시오.

파이썬 3 , 189 바이트

순수한 단일 라이너로 만든 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.

파이썬 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

온라인으로 사용해보십시오!

조기 침입을 통한 정규 중첩 for 루프 return는 "영리한"트릭보다 훨씬 짧습니다 any.

C (gcc) , 240 (238) 227 225 222 216 바이트

• 2 바이트를 절약했습니다. 부유 변수 정의를 제거했습니다.
• 11 개의 13 바이트를 절약했습니다 . 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.
• 3 바이트를 절약했습니다. 골프 for(...;...;p++)S[p+1]=S[p+L];를 쳤다for(...;...;S[++p]=S[p+L]); .
• 덕분에 6 바이트 절약 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;}

온라인으로 사용해보십시오!

파이썬 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

정규식 접근 방식을 사용합니다. 반복적으로 문자열을 교체합니다. 현재 값의 각 연속 하위 문자열에서 이들을 빌드합니다. 예를 들어 입력 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

Wolfram Language (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