Réduire l'antistring

27

Dans ce défi, vous recevrez une chaîne alphabétique en entrée. Nous définirons "l'anti-chaîne" d'une entrée donnée comme étant la chaîne avec la casse de toutes les lettres inversées. Par exemple

AaBbbUy -> aAbBBuY

Vous devez écrire un programme qui prend une chaîne en entrée et recherche la sous-chaîne contiguë la plus longue dont l'anti-chaîne est également une sous-chaîne contiguë. Les deux sous-chaînes ne doivent pas se chevaucher.

Par exemple, si vous avez reçu la chaîne

fAbbAcGfaBBagF

Les parties en gras seraient la paire anti-cordes la plus longue.

Votre programme doit, une fois qu'il a trouvé la paire, les réduire en un seul caractère chacun. Il doit le faire en supprimant tout sauf le premier caractère de chaque sous-chaîne. Par exemple, la chaîne ci-dessus

fAbbAcGfaBBagF

deviendrait 

fAcGfagF

Votre programme doit ensuite répéter le processus jusqu'à ce que la paire anti-chaîne la plus longue soit un seul caractère ou plus courte.

Par exemple, en travaillant avec la même chaîne, la nouvelle paire la plus longue après l'effondrement est

fAcGfagF

Donc, nous réduisons à nouveau la chaîne

fAcGag

Maintenant, la chaîne ne peut plus être réduite, nous devons donc la sortir.

Dans le cas d'une égalité entre les paires de candidats (exemple AvaVA), vous pouvez effectuer l'une AaAou l' autre réduction ( ou AvV, mais pas Aa).

Il s'agit de code-golf donc les réponses seront notées en octets avec moins d'octets mieux.

Cas de test

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

Les motivations

Bien que ce problème puisse sembler arbitraire, c'est en fait un problème que j'ai rencontré lors de la création de code pour traiter les polygones fondamentaux. Ce processus peut être utilisé pour réduire un polygone fondamental à un n -gon plus petit . Après l'avoir essayé, j'ai pensé que cela ferait un joli petit golf.

code-golf  string  subsequence 
— Assistant de blé
source
Si la plus grande sous-chaîne avec des sous-chaînes anti-chaîne a plus d'une sous-chaîne anit-chaîne, toutes les sous-chaînes doivent-elles être réduites ou seulement les deux premières?
— Jonathan Frech
@JonathanFrech Deux quelconques. C'est un cas où il y a un lien entre les paires de candidats.
— Wheat Wizard
Alors aaaAAAaaa -> aAaaa?
— Jonathan Frech
Quelque chose dans un sous-ensemble de ce problème crie, mais je ne peux pas mettre le doigt dessus.
— Magic Octopus Urn
1
@MagicOctopusUrn Quelque chose comme Écrire un quine à deux cycles où la sortie du programme est son antistring ?
— Jonathan Frech

Réponses:

8

Perl, 64 61 octets

Comprend +1pourp

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

JavaScript (ES6), 200 octets

Utilise des tableaux de caractères pour les E / S.

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

Essayez-le en ligne!

— Arnauld
source
3

Rétine , 119 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

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

Dupliquez l'entrée et retournez le cas de la première copie.

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

S'il n'y a pas d'anti-chaînes du tout, supprimez le double retourné.

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

Liste toutes les anti-chaînes réduites possibles.

N$`
$.&
}0G`

Triez-les par ordre de longueur, prenez la plus courte (c'est-à-dire la plus longue anti-chaîne) et répétez jusqu'à ce que toutes les anti-chaînes aient été réduites.

— Neil
source
3

Python 3 , 189 181 octets

Nous remercions Jonathan Frech pour l'avoir rendu pur doublure.

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

Essayez-le en ligne!

Ma propre version, désormais obsolète (189 octets):

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

Essayez-le en ligne!

any()pour briser les boucles imbriquées tôt, et set()pour un objet global mutable utilisable dans la compréhension. Le reste n'est que la simple mise en œuvre des exigences à l'aide str.swapcase.

Python 2 , 160 octets

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

Essayez-le en ligne!

Il s'avère que la boucle imbriquée régulière avec une percée précoce returnest beaucoup plus courte que l'astuce "intelligente" any.

— Bubbler
source
181 octets ; approche récursive. Le mutable en settant que fonction par défaut ne entrera pas en collision avec d'autres appels, car je pense que votre code affiche complètement l'ensemble pour qu'il soit vide.
— Jonathan Frech
Désolé, je pensais que cela xne serait pas vide. Comme vous l'avez, je pense qu'il est conforme.
— Jonathan Frech
C'est bien, et merci pour l'amélioration.
— Bubbler
3

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

  • Enregistré deux octets; supprimé une définition de variable parasite.
  • Enregistré onze treize octets; joué b|=S[p+m]!=S[q+m]+32-(S[q+m]>90)*64au golf b|=abs(S[p+m]-S[q+m])-32à b|=32-S[p+m]+S[q+m]&63.
  • Enregistré trois octets; joué for(...;...;p++)S[p+1]=S[p+L];au golf for(...;...;S[++p]=S[p+L]);.
  • Économisé six octets grâce au plafond .
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;}

Essayez-le en ligne!

— Jonathan Frech
source
@ceilingcat Merci.
— Jonathan Frech
0

Python 2 , 180 octets

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

Essayez-le en ligne!

— Chas Brown
source
0

Stax , 30 octets

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

Exécuter et déboguer

La représentation ascii correspondante du même programme est la suivante.

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

Il utilise une approche regex. Il regex à plusieurs reprises le remplacement de chaîne. Il les construit à partir de chaque sous-chaîne contiguë de la valeur actuelle. Par exemple pour l'entrée fAbbAcGfaBBagF, l'une des sous-chaînes est AbbA, auquel cas l'expression régulière AbbA(.*)aBBasera remplacée par 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
— récursif
source
0

Japt -h , 33 octets

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

Essayez-le

à ñÊÅÔ£=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
— Hirsute
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.