이 과제에서 X, Y 및 Z의 문자열을 포함하는 입력으로 문자열을받습니다. "XYZZ". X, Y 및 Z는 특정 문자를 나타냅니다. 그런 다음이 패턴을 두 번째 문자열 입력과 비교합니다. 패턴이 두 번째 입력에 하위 문자열로 존재하면를 반환하고 True, 그렇지 않으면를 반환 False합니다. 단어에서 패턴이 발견되면 프로그램은 검색을 중지하고를 반환합니다 True.

예

패턴 : "XXYY"

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

패턴 : "XYXYZ"

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

• 참고 : 이것은 실제 입력이 아닙니다. 프로그램이 작동하는 방법의 예입니다. 프로그램은 True또는 False, 또는 다른 Truthy / Falsy 값을 출력해야 합니다.

다른 중요한 / 유용한 정보

• 패턴은 X, Y 및 Z를 포함 할 필요가 없으며, X 및 Y를 포함하거나 심지어 X를 포함 할 수도 있습니다.
• 패턴은 비워 둘 수 없지만 테스트 케이스로 사용되지는 않습니다.
• 검색 문자열은 비어 있지 않으며 소문자입니다.
• 패턴에서 X, Y 및 Z의 알파벳 순서는 중요하지 않습니다.
• X, Y 및 Z 는 고유 한 문자 여야합니다 .
• 원하는 라이브러리를 사용할 수 있습니다.
• 점수는 코드 크기 ( 바이트 )로 결정됩니다 . 최저 점수가 이깁니다.

행운을 빕니다!

펄 5 , 85 바이트

Peter Taylor의 제안 덕분에 40 바이트가 절약되었습니다! (차이점을 보려면 이전 버전을 참조하십시오)

83 바이트의 코드 + -pl플래그.

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

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

XYXYZ는 ((?!\1).)((?!\1)(?!\2).)\1\2((?!\1)(?!\2)(?!\3).)( 그렇지만 일부 테스트는 사실 일 수는 없지만 그렇게 짧습니다)로 변환되고 두 번째 입력은 해당 정규식에 대해 검사됩니다. (작동 방식에 대한 더 직관을 얻으려면 이전 버전의 설명을 참조하십시오)

내 이전 버전 :
첫 번째 버전에서 실수를 지적 해 준 Arnauld에게 감사합니다.
코드 + 113 바이트 -pl플래그 및 -Mre=eval.

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

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

(.) (.) (.) 예제 XYXYZ의 제 정규식에 패턴으로 변환한다 \ 1 \ 2, 마지막에 있는지 확인하는 테스트를 추가 $1, $2및 $3다른 그래서, 만약 $\하나에 설정된다. 그런 다음 두 번째 입력은이 정규식에 대해 테스트 $\되며 끝 부분에 암시 적으로 인쇄됩니다.
XYXYZ에 대해 생성 된 정규식은 (.)(.)\1\2(.)(?{++$c;$\=1if!grep{$v{$c}{${$_}}++}1..3})^입니다.
(잠깐 시간을 내면 설명에 더 자세한 내용을 추가하겠습니다.)

젤리 , 9 바이트

=þ
ẆÇ€ċÇ}

패턴이 발견 된 횟수를 리턴합니다. 0이 아닌 값은 진실이고 0은 거짓입니다.

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

작동 원리

ẆÇ€ċÇ}  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.

자바 스크립트 (ES6), 94 바이트

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>

패턴을 정규 표현식으로 변환하여 작동합니다 (예 : XYXYZ생성) /(.)(?!\1)(.)\1\2(?!\2)(?!\1)(.)/.

PCRE와 JavaScript regexp 사이에 흥미로운 차이점이 있습니다. PCRE 에서는 캡처 그룹이 정의되기 전에 \<n>실패하고 (?!\<n>)성공 하므로 JavaScript는 빈 문자열과 성공적으로 일치하므로 (?!\<n>)실패합니다.

파이썬 2 , 70 바이트

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

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

이 답변 의 메소드를 사용하여 문자열이 패턴과 일치하는지 확인합니다 . 길이가 패턴과 같은 검색 문자열의 접두사를 사용합니다. 일치하는 것을 찾을 때까지 또는 False비어있는 경우 문자열 문자열의 첫 문자를 잘라냅니다.

73 바이트 :

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

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

이 답변 의 메소드를 사용하여 문자열이 패턴과 일치하는지 확인합니다 . 문자열이 비워 질 때까지 첫 번째 또는 마지막 문자를 제거하여 분기하여 모든 하위 문자열을 재귀 적으로 검사합니다.

파이썬 3 , 100 바이트

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:]))

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

05AB1E , 19 16 바이트

ÙœJv¹y…XYZ‡²åi1q

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

Ùœ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.

true이면 1을 반환하고, true가 아니면 null을 반환합니다.

가능한 XYZ 값 리턴이 허용되는 경우 14 바이트 일 수 있습니다.

05AB1E , 14 바이트

ÙœJv¹y…XYZ‡²å—

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

자바 7 177 176 173 바이트

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;}

설명:

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

테스트 코드 :

여기에서 시도하십시오.

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"));
  }
}

산출:

true
false
true
true
false

PHP, 89 바이트

에서 선물 @Christoph 및 @Titus

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

PHP, 105 바이트

@Christoph의 선물

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

PHP, 167 바이트

[,$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 바이트

감사합니다 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;}

역 추적 솔루션, 보너스로 모든 캐릭터의 패턴과 함께 작동합니다!

    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;
    }

루비, 63 61 바이트

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

정규식 패턴을 검색하는 대신 가능한 모든 방법으로 'X', 'Y'및 'Z'를 대체하고 리터럴 일치를 찾으십시오.

(실제로 carusocomputing의 05AB1E 답변과 동일한 개념)

자바 스크립트 (ES6), 92 89 87 86 바이트

카레 구문에서 입력 p(패턴) 및 s(문자열)을 사용합니다 (p)(s). 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)

형식화 및 의견

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'
    )                            //

테스트 사례

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 자 (문자열 및 패턴 제외)

StringContainsQ[string,pattern]

예 :

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

True

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

True