In questa sfida ti verrà fornita una stringa alfabetica come input. Definiremo l'anti-stringa di un dato input come stringa con il caso di tutte le lettere invertite. Per esempio

AaBbbUy -> aAbBBuY

È necessario scrivere un programma che accetta una stringa come input e cerca la sottostringa contigua più lunga il cui anti-stringa è anche una sottostringa contigua. Le due sottostringhe non devono sovrapporsi.

Ad esempio se ti è stata data la stringa

fAbbAcGfaBBagF

Le parti in grassetto sarebbero la coppia anti-stringa di stringa più lunga.

Il tuo programma dovrebbe, una volta trovata la coppia, comprimerli in un singolo carattere ciascuno. Dovrebbe farlo rimuovendo tutto tranne il primo carattere di ogni sottostringa. Ad esempio la stringa sopra

fAbbAcGfaBBagF

potrebbe diventare

fAcGfagF

Il programma dovrebbe quindi ripetere il processo fino a quando la coppia anti-stringa di stringa più lunga è un singolo carattere o più corta.

Ad esempio, lavorando con la stessa stringa è la nuova coppia più lunga dopo il crollo

fAcGfagF

Quindi comprimiamo di nuovo la stringa

fAcGag

Ora la stringa non può essere ulteriormente compressa, quindi dovremmo emetterla.

Nel caso di un pareggio tra coppie candidate (esempio AvaVA) è possibile effettuare una riduzione ( AaAo AvV, ma non Aa).

Questo è code-golf, quindi le risposte verranno classificate in byte con un numero inferiore di byte migliori.

Casi test

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

motivazioni

Mentre questo problema può sembrare arbitrario, in realtà è un problema che ho riscontrato durante la creazione di codice per elaborare poligoni fondamentali. Questo processo può essere utilizzato per ridurre un poligono fondamentale a un n -gon più piccolo. Dopo averlo provato, ho pensato che sarebbe stato un bel piccolo golf.

Perl, 64 61 byte

Include +1perp

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

JavaScript (ES6), 200 byte

Utilizza matrici di caratteri per l'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

Provalo online!

Retina , 119 byte

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

Provalo online! Il link include casi di test. Spiegazione:

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

Duplica l'input e capovolgi il caso della prima copia.

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

Se non ci sono anti-stringhe, elimina il duplicato capovolto.

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

Elenca tutte le possibili stringhe compresse.

N$`
$.&
}0G`

Ordinali in ordine di lunghezza, prendi il più corto (cioè il più lungo anti-stringa) e ripeti fino a quando tutte le anti-stringhe non sono state collassate.

Python 3 , 189 181 byte

Ringraziamo Jonathan Frech per averlo reso puro.

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

Provalo online!

La mia versione, ora obsoleta (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

Provalo online!

any()per spezzare in anticipo i cicli annidati e set()per un oggetto globale mutevole utilizzabile nella comprensione. Il resto è solo l'implementazione diretta dei requisiti usando 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

Provalo online!

Si scopre che il normale ciclo annidato per loop con sfondamento anticipato returnè molto più breve del trucco "intelligente" any.

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

• Due byte salvati; rimossa una definizione variabile vagante.
• Salvati undici tredici byte; golfed b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64per b|=abs(S[p+m]-S[q+m])-32a b|=32-S[p+m]+S[q+m]&63.
• Tre byte salvati; golf for(...;...;p++)S[p+1]=S[p+L];a for(...;...;S[++p]=S[p+L]);.
• Risparmiato sei byte grazie a 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;}

Provalo 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

Provalo online!

Stax , 30 byte

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

Esegui ed esegui il debug

La corrispondente rappresentazione ASCII dello stesso programma è questa.

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

Usa un approccio regex. Ripete ripetutamente la sostituzione della stringa. Costruisce questi da ogni sottostringa contigua del valore corrente. Ad esempio per l'input fAbbAcGfaBBagF, una delle sottostringhe è AbbA, nel qual caso il regex AbbA(.*)aBBaverrà sostituito con 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 byte

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

Provalo online!

Japt -h , 33 byte

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

Provalo

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