Dans ce défi, vous recevez une chaîne en entrée contenant une chaîne de X, Y et Z par exemple. "XYZZ". X, Y et Z représentent un caractère particulier. Ce modèle est ensuite comparé à une deuxième entrée de chaîne. Si le modèle existe en tant que sous-chaîne dans la deuxième entrée, retournez True, sinon, retournez False. Une fois qu'un motif est trouvé dans le mot, le programme arrête la recherche et revient True.

Exemples

Motif: "XXYY"

succeed ---> True (pattern found: ccee)
success ---> False (pattern not matched)
balloon ---> True (pattern found: lloo)

Motif: "XYXYZ"

bananas ---> True (pattern found: nanas)
banana  ---> False (pattern not found)

• Remarque: Ce n'est pas l'entrée réelle. Ceci est un exemple de la façon dont le programme devrait fonctionner. Votre programme doit afficher Trueou False, ou d'autres valeurs Truthy / Falsy.

Autres informations importantes / utiles

• Le motif n'a pas besoin de contenir un X, Y et un Z, il peut contenir des X et des Y ou même (bien que quelque peu inutile) que des X.
• Le modèle ne peut pas être vide, mais il ne sera pas utilisé comme cas de test.
• La chaîne de recherche ne sera pas vide et sera en minuscules.
• L'ordre alphabétique de X, Y et Z dans le motif n'a pas d'importance.
• X, Y et Z doivent être des caractères uniques.
• Vous pouvez utiliser n'importe quelle bibliothèque de votre choix.
• Le score est déterminé par la taille du code , en octets. Le score le plus bas l'emporte.

Bonne chance!

Perl 5 , 85 octets

Enregistré 40 octets grâce à la suggestion de Peter Taylor! (voir mon ancienne version ci-dessous pour voir les différences)

83 octets de code + -plindicateur.

s/./$h{$&}?"\\$h{$&}":($h{$&}=$.,join("",map"(?!\\$_)",1..$.++)."(.)")/ge;$_=<>=~$_

Essayez-le en ligne!

XYXYZ est transformé en ((?!\1).)((?!\1)(?!\2).)\1\2((?!\1)(?!\2)(?!\3).)(oui, certains des tests ne peuvent pas être vrais, mais c'est plus court de cette façon), et la deuxième entrée est ensuite vérifiée par rapport à cette expression régulière. (voir les explications de mon ancienne version pour avoir plus d'intuition sur son fonctionnement)

Mon ancienne version:
Merci à Arnauld d'avoir signalé une erreur que j'ai faite dans ma première version.
113 octets de code + -pldrapeaux, et -Mre=eval.

s/./$h{$&}?"\\$h{$&}":($h{$&}=++$i,"(.)")/ge;$_.='(?{++$c;$\=1if!grep$v{$c}{${$_}}++,1..'.(keys%h).'})^';<>=~$_}{

Essayez-le en ligne!

Sur l'exemple XYXYZ: le premier regex convertira le modèle en (.) (.) \ 1 \ 2 (.), Et ajoutera à la fin un test pour vérifier si $1, $2et $3sont différents: si c'est le cas, $\est réglé sur un. Ensuite, la deuxième entrée est testée par rapport à cette expression régulière et $\est implicitement imprimée à la fin.
Le regex généré pour XYXYZ est (.)(.)\1\2(.)(?{++$c;$\=1if!grep{$v{$c}{${$_}}++}1..3})^.
(Je vais ajouter un peu plus de détails aux explications quand j'aurai un moment)

Gelée , 9 octets

=þ
ẆÇ€ċÇ}

Renvoie le nombre de fois où le motif a été trouvé, non nul étant vrai et zéro étant faux.

Essayez-le en ligne!

Comment ça marche

ẆÇ€ċÇ}  Main link. Left argument: s (string). Right argument: p (pattern)

Ẇ       Window; generate all substrings of s.
 ǀ     Map the helper link over the substrings.
    Ç}  Apply the helper link to p.
   ċ    Count the number of times the right result appears in the left result.


=þ      Helper link. Argument: t (string)

=þ      Compare all characters of t for equality with all characters of t, yielding
        a square matrix of Booleans.

JavaScript (ES6), 94 octets

f=
(p,s)=>s.match(p.replace(/./g,c=>m[c]||(t=r,r=`(?!\\${++g})`+r,m[c]=`\\`+g,t),g=m=[],r=`(.)`))

<div oninput=o.textContent=!!f(p.value,s.value)><input id=p placeholder=Pattern><input id=s placeholder=String><span id=o>

Fonctionne en transformant le motif en expression rationnelle, par exemple car XYXYZil génère /(.)(?!\1)(.)\1\2(?!\2)(?!\1)(.)/.

Je remarque une distinction intéressante entre PCRE et regexp JavaScript: dans PCRE, \<n>échoue (et (?!\<n>)réussit donc ) avant que le groupe de capture ne soit défini, tandis que JavaScript correspond avec succès à la chaîne vide (et (?!\<n>)échoue donc ).

Python 2 , 70 octets

f=lambda p,s:s>''and(map(s.find,s[:len(p)])==map(p.find,p))|f(p,s[1:])

Essayez-le en ligne!

Vérifie si une chaîne correspond à un modèle en utilisant la méthode de cette réponse . Utilise un préfixe de la chaîne de recherche dont la longueur est égale au modèle. Coupe le premier caractère de la chaîne jusqu'à ce qu'une correspondance soit trouvée, ouFalse si elle devient vide

73 octets:

f=lambda p,s:s>''and(map(s.find,s)==map(p.find,p))|f(p,s[1:])|f(p,s[:-1])

Essayez-le en ligne

Vérifie si une chaîne correspond à un modèle en utilisant la méthode de cette réponse . Vérifie récursivement toutes les sous-chaînes en se ramifiant en supprimant le premier ou le dernier caractère jusqu'à ce que la chaîne soit vide.

Python 3 , 100 octets

l=len
f=lambda p,s:l(p)<=l(s)and(l({*zip(p,s)})==l({*p})==l({s for _,s in{*zip(p,s)}})or f(p,s[1:]))

Essayez-le en ligne!

05AB1E , 19 16 octets

ÙœJv¹y…XYZ‡²åi1q

Essayez-le en ligne!

ÙœJ              # Get powerset of all unique characters in string.
   v             # Loop through each...
    ¹            # Push input word.
     y           # Push current set of letters in powerset.
      …XYZ‡      # Replace each of the 3 letters in the original word with XYZ.
           ²å    # Check if second input is in this string, push 1 if it is.
             i1q # If 1, push 1 and quit.

Renvoie 1 si vrai, nul sinon faux.

Cela peut être de 14 octets si le retour des valeurs possibles de XYZ est autorisé:

05AB1E , 14 octets

ÙœJv¹y…XYZ‡²å—

Essayez-le en ligne 2!

Java 7, 177 176 173 octets

Object c(String p,String s){int i=p.length();if(s.length()<i)return 0>1;for(;i-->0;)if(p.indexOf(p.charAt(i))!=s.indexOf(s.charAt(i)))return c(p,s.substring(1));return 1>0;}

Explication:

Object c(String p, String s){                             // Method with two String parameters and Object return-type
  int i = p.length();                                     //  Index that starts at the length of the pattern
  if(s.length() < i)                                      //  If the length of the input is smaller than the length of the pattern
    return 0>1;//false                                    //   Simply return false
  for(;i-->0;)                                            //  Loop from 0 to length_of_pattern
    if(p.indexOf(p.charAt(i)) != s.indexOf(s.charAt(i)))  //   If the index of the characters of the pattern and input aren't matching
     return c(p, s.substring(1));                         //    Return the recursive-call of pattern and input minus the first character
                                                          //  End of loop (implicit / single-line body)
  return 1>0;//true                                       //  If every index of the characters are matching: return true
}                                                         // End of method

Code de test:

Essayez-le ici.

class M{
  static Object c(String p,String s){int i=p.length();if(s.length()<i)return 0>1;for(;i-->0;)if(p.indexOf(p.charAt(i))!=s.indexOf(s.charAt(i)))return c(p,s.substring(1));return 1>0;}

  public static void main(String[] a){
    System.out.println(c("XXYY", "succeed"));
    System.out.println(c("XXYY", "success"));
    System.out.println(c("XXYY", "balloon"));

    System.out.println(c("XYXYZ", "bananas"));
    System.out.println(c("XYXYZ", "banana"));
  }
}

Sortie:

true
false
true
true
false

PHP, 89 octets

Un cadeau de @Christoph et @Titus

for(;$v=$argv[1][$i++];)$r.=$$v?"\\".$$v:"(.)".!$$v=++$j;echo preg_match("#$r#",$argv[2]);

PHP, 105 octets

Un cadeau de @Christoph

foreach(str_split($argv[1])as$v)$r.=$x[$v]?"\\$x[$v]":"(.)".!$x[$v]=++$y;echo preg_match("#$r#",$argv[2]);

PHP, 167 octets

[,$a,$b]=$argv;foreach($s=str_split($a)as$v)$r[]=$k++>strpos($a,$v)?"\\".(1+array_search($v,array_keys(array_count_values($s)))):"(.)";echo preg_match(_.join($r)._,$b);

C #, 184 165 155 octets

merci aloisdg!

bool c(string p,string n){for(int l=p.Length,i=0,j;i<l;i++)for(j=i;j>=0;)if(p[i]==p[j]==(n[i]!=n[j--]))return l!=n.Length&&c(p,n.Substring(1));return 2>1;}

solution de retour en arrière, en prime, elle fonctionne avec un motif avec des caractères!

    public static bool c(string p,string n)
    {
        for (int l = p.Length, i = 0, j; i < l; i++)
            for (j = i; j >= 0;)
                if (p[i]==p[j]==(n[i]!=n[j--]))
                    return l != n.Length && c(p,n.Substring(1));
        return 2>1;
    }

Rubis, 63 61 octets

->a,b{a.chars.permutation.any?{|w|a.tr((w|[])*'','XYZW')[b]}}

Au lieu de rechercher un modèle d'expression régulière, essayez simplement de remplacer «X», «Y» et «Z» de toutes les manières possibles, et trouvez une correspondance littérale.

(En fait, le même concept que la réponse 05AB1E de carusocomputing)

JavaScript (ES6), 92 89 87 86 octets

Prend entrée p (modèle) et s(chaîne) dans la syntaxe de curry (p)(s). Renvoie 0/ 1.

p=>g=s=>s&&g(s.slice(1))|[...p].every((C,i,x)=>C==(x[c=s[i]]=x[c]||'XYZ'[c&&j++]),j=0)

Formaté et commenté

p =>                             // main function: takes pattern p as input, returns g
  g = s =>                       // g = recursive function: takes string s as input
    s &&                         // if s is not empty:
      g(s.slice(1))              //   do a recursive call, starting at the next character
    |                            // merge the result with this iteration
    [...p].every((C, i, x) =>    // for each character C at position i in p:
      C ==                       //   check whether C is matching the next expected
      (                          //   character, which is either:
        x[c = s[i]] = x[c] ||    //   - a substitution character already associated to s[i]
        'XYZ'[c && j++]          //   - the next substitution character ('X', 'Y' or 'Z')
      ),                         //   - undefined if c = s[i] doesn't exist or j > 2
      j = 0                      //   initialize j = pointer in 'XYZ'
    )                            //

Cas de test

let f =

p=>g=s=>s&&g(s.slice(1))|[...p].every((C,i,x)=>C==(x[c=s[i]]=x[c]||'XYZ'[c&&j++]),j=0)

console.log(f("XXYY")("succeed"))   // 1
console.log(f("XXYY")("success"))   // 0
console.log(f("XXYY")("balloon"))   // 1
console.log(f("XYXYZ")("bananas"))  // 1
console.log(f("XYXYZ")("banana"))   // 0

Mathematica 18 caractères (sans compter la chaîne et le motif)

StringContainsQ[string,pattern]

Exemples:

StringContainsQ["succeed", x_ ~~ x_ ~~ y_ ~~ y_]

True

StringContainsQ["bananas", x_ ~~ y_ ~~ x_ ~~ y_ ~~ z_]

True