इस चुनौती में, आपको एक स्ट्रिंग मिलती है इनपुट के रूप में एक्स, वाई और जेड की एक स्ट्रिंग होती है। "XYZZ"। एक्स, वाई और जेड एक विशेष चरित्र का प्रतिनिधित्व करते हैं। यह पैटर्न दूसरे स्ट्रिंग इनपुट के साथ तुलना में है। यदि पैटर्न दूसरे इनपुट में एक विकल्प के रूप में मौजूद है, तो वापस लौटें 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, या अन्य ट्रू / फाल्सी वैल्यूज होना चाहिए ।

अन्य महत्वपूर्ण / उपयोगी जानकारी

पैटर्न में एक एक्स, वाई और एक जेड शामिल होने की आवश्यकता नहीं है, इसमें एक्स और वाई या यहां तक कि (हालांकि कुछ हद तक व्यर्थ) बस एक्स हो सकता है।
पैटर्न खाली नहीं हो सकता है, लेकिन इसका उपयोग परीक्षण के मामले के रूप में नहीं किया जाएगा।
खोज स्ट्रिंग खाली नहीं होगी, और लोअरकेस होगी।
पैटर्न में X, Y और Z का वर्णानुक्रम क्रम मायने नहीं रखता है।
X, Y और Z अद्वितीय वर्ण होने चाहिए ।
आप अपनी इच्छानुसार किसी भी पुस्तकालय का उपयोग कर सकते हैं।
स्कोर को बाइट्स में कोड आकार द्वारा निर्धारित किया जाता है । सबसे कम स्कोर जीतता है।

सौभाग्य!

code-golf

— notHalfBad
स्रोत

पैटर्न कुछ भी हो सकता है। मुझे शायद इस बात का उल्लेख करना चाहिए कि पैटर्न के पास X, Y और Z होना आवश्यक नहीं है, यह सिर्फ एक X और Y हो सकता है। वे पैटर्न सिर्फ उदाहरण हैं, हालांकि, अपने स्वयं के साथ आने के लिए स्वतंत्र महसूस करें। उन पैटर्न के साथ उदाहरण।

— NotHalfBad

आपका क्या मतलब है "पैटर्न मौजूद है"? एक सन्निहित ठग के रूप में? एक विकल्प के रूप में? कह सकते हैं, X और Y एक ही चीज़ के लिए खड़े हैं?

— xnor

@ एक्सनोर एक्स और वाई प्रत्येक अभिभावक से स्वतंत्र होना चाहिए, और मौजूदा पैटर्न से मेरा मतलब है कि स्ट्रिंग में कहीं भी एक विकल्प है जो पैटर्न से मेल खाता है। मैं इन्हें स्पष्ट करने के लिए अपने चुनौती विवरण में शामिल करूंगा।

— notHalfBad

3

सम्बंधित। (एक ही बात है, लेकिन सबस्ट्रिंग के लिए नहीं, पैटर्न के सटीक मैचों के लिए पूछता है।)

— मार्टिन एंडर

4

अधिक विवरण: क्या पैटर्न खाली हो सकता है? खोज स्ट्रिंग? क्या खोज स्ट्रिंग केवल लोअरकेस अक्षरों का उपयोग करेगी? क्या यह पैटर्न वर्णानुक्रम में पहले समान पैटर्न के बीच होगा, अर्थात X का उपयोग पहले Y फिर Z से होगा?

— xnor

12

पर्ल 5 , 85 बाइट्स

पीटर टेलर के सुझाव के लिए धन्यवाद 40 बाइट्स बचाए! (अंतर देखने के लिए मेरे पुराने संस्करण को देखें)

कोड + -plध्वज के 83 बाइट्स ।

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

इसे ऑनलाइन आज़माएं!

XYXYZ ((?!\1).)((?!\1)(?!\2).)\1\2((?!\1)(?!\2)(?!\3).)(yup में बदल जाता है , कुछ परीक्षण सही नहीं हो सकते, लेकिन यह इस तरह छोटा है), और दूसरा इनपुट फिर उस regex के खिलाफ जांचा जाता है। (यह कैसे काम करता है के अधिक अंतर्ज्ञान पाने के लिए मेरे पुराने संस्करण की व्याख्या देखें)

मेरा पुराना संस्करण:
मेरे पहले संस्करण में मुझसे हुई एक गलती की ओर इशारा करने के लिए अरनौलद को धन्यवाद।
कोड + -plझंडे के 113 बाइट्स , और -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})^।
(मेरे पास एक क्षण होने पर स्पष्टीकरण में थोड़ा और विवरण जोड़ सकता हूं)

— बापू
स्रोत

तो, रेगेक्स का उपयोग करके रेगेक्स को नॉन-रेगेक्स चालू करना है? कूलियो

— मैथ्यू रो

@Arnauld वास्तव में, धन्यवाद। (मैंने चुनौती को बहुत तेजी से पढ़ा होगा, मेरा बुरा)। इसे ठीक करने के लिए बायटेकाउंट को दोगुना करना था, लेकिन अब यह काम करता है!

— दादा

क्या यह रेगेक्स उत्पन्न करने के लिए गोल्फर नहीं होगा (.)((?!\1).)\1\2((?!\1)(?!\2).)?

— पीटर टेलर

@Peter टेलर हो सकता है .. मैं अस्पष्ट रूप से इसके बारे में सोचा था, लेकिन यह कठिन (लंबे समय तक पढ़ें) उत्पन्न करने के लिए लग रहा था .. मेरे पास एक और नज़र होगी जब मेरे पास एक पल होगा।

— दादा

@ पेटर टेलर कभी नहीं, यह 30 बाइट्स छोटा होने जा रहा है; मैं इसे थोड़ा सा अपडेट करूँगा, धन्यवाद :)

— दादा

10

जेली , 9 बाइट्स

=þ
ẆÇ€ċÇ}

रिटर्न पैटर्न की संख्या जितनी बार मिली, गैर-शून्य सत्य और शून्य मिथ्या रही।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

— डेनिस
स्रोत

8

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

पैटर्न को regexp में बदलकर काम करता है, उदाहरण के लिए XYXYZयह उत्पन्न करता है /(.)(?!\1)(.)\1\2(?!\2)(?!\1)(.)/।

मैं PCRE और जावास्क्रिप्ट regexp के बीच एक दिलचस्प अंतर को नोटिस करता हूं: PCRE में, कैप्चर समूह को परिभाषित करने से पहले \<n>विफल हो जाता है (और इसलिए (?!\<n>)सफल होता है), जबकि जावास्क्रिप्ट यह खाली स्ट्रिंग (और इसलिए (?!\<n>)विफल) से मेल खाता है ।

— नील
स्रोत

7

पायथन 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])

इसे ऑनलाइन आज़माएं

जाँचता है कि क्या कोई स्ट्रिंग इस उत्तर में विधि का उपयोग करके एक पैटर्न से मेल खाती है । स्ट्रिंग के खाली होने तक पहले या अंतिम चरित्र को हटाने के लिए पुनरावर्तन करके सभी सबस्ट्रिंग्स की पुन: जाँच करता है।

— XNOR
स्रोत

6

पायथन 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:]))

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

4

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.

1 लौटेगा तो सही, अगर सही नहीं है तो अशक्त।

यह 14 बाइट्स हो सकता है यदि XYZ के संभावित मूल्यों को वापस करने की अनुमति है:

05AB1E , 14 बाइट्स

ÙœJv¹y…XYZ‡²å—

यह ऑनलाइन 2 की कोशिश करो!

— जादू ऑक्टोपस Urn
स्रोत

यह मानते हुए कि 05AB1E में एक गैर-रिक्त स्ट्रिंग सत्य है और एक खाली एक गलत है, आपके दूसरे संस्करण को कल्पना का अनुपालन करना चाहिए।

— डेनिस

1

इनपुट "abcd" और "XYZZ" पर गलत परिणाम। आपको डिफ़ॉल्ट प्रतिस्थापन के रूप में एक चौथा अक्षर जोड़ना होगा।

— GB

@ डेनिस: यदि हम मेटा द्वारा जाते हैं तो 05AB1E में एकमात्र सत्य मान है 1और True(जो आमतौर पर इस प्रकार की चुनौतियों के लिए एक दोष है), लेकिन अगर चुनौती की व्याख्या की जा सकती है तो हमें चुनौती के लिए सच्चाई / काल्पनिकता को परिभाषित करने की अनुमति देनी चाहिए। दूसरा संस्करण आपके कहे अनुसार काम करता है।

— एमिग्ना

@Eigna ओह, मैं उस से अनजान था।

— डेनिस

4

जावा 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

— केविन क्रूज़सेन
स्रोत

4

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

— जार्ग हुल्सरमन
स्रोत

1

आपको ++$pइसके बजाय 2 बाइट्स बचाने में सक्षम होना चाहिए ($p+1), हालांकि मैंने वास्तव में इसका परीक्षण नहीं किया है।

— user59178

1

मेरे लिए काम नहीं करता है: सैंडबॉक्स । वैसे भी कोड का एक गोल्फ संस्करण [,$a,$b]=$argv;foreach(str_split($a)as$k=>$v)$r.=$k==($p=strpos($a,$v))?"(.)":"\\".++$p;echo preg_match("#$r#",$b);:।

— क्रिस्टोफ

1

इसे एक उपहार के रूप में लें: [,$a,$b]=$argv;foreach(str_split($a)as$v)$r.=$x[$v]?"\\$x[$v]":'(.)'.!$x[$v]=++$y;echo preg_match("#$r#",$b);(ध्यान दें कि आपको अपने पुराने स्कोर का उपयोग करना चाहिए <strike>)

— क्रिस्टोफ़

1

@Christoph A उपहार के साथ सीखने का प्रयास था !। यह तब और अधिक सार्थक है जब मैं आपके अच्छे समाधान के साथ पहुँच सकता हूँ।

— जोर्ग हल्सरमैन

1

मैं गिनती 109, नहीं 108. -3 बाइट्स यदि आप प्रतिलिपि नहीं है $argvकरने के लिए $aऔर $b; -6 बाइट्स के साथ for(;a&$v=$argv[1][$i++];); -1 अब चर नाम के साथ बाइट ( वास्तव में! : उपयोग $vvकरने के बजाय $v, $iiके बजाय $i, $rrके बजाय $r, $yyके बजाय $yऔर आप उपयोग कर सकते हैं $$vvके बजाय $x[$v])

— टाइटस

4

सी #, 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;
    }

— downrep_nation
स्रोत

मैं सिर्फ यह देखा कि यह तर्क मैं उजागर नहीं किया था गोल्फिंग, जल्द ही अद्यतन करेगा

— downrep_nation

2

सबसे पहले, क्यों var s=l==n.Length;? आप इसका उपयोग केवल return s?!s:(जहां !sहमेशा होता है false) पर करते हैं, इसलिए इसे परिवर्तित किया जा सकता है return l==n.Length?0>1:। इसके अलावा, यह क्या है (n[i]!=n[j]||n[i]!=n[j]):। आप n[i]!=n[j]दो बार चेक करें .. यह हमेशा रहेगा true or true/ false or false..: S

— केविन क्रूज़सेन

डबल चेक वास्तव में एक बड़े से बचा है अगर सिस्टम जो कि गोल्फ में गायब हो गया था, इसलिए एस का उपयोग किया गया था, मैं इसे और सुधारता हूं। धन्यवाद!

— downrep_nation

आप अपने सभी वैरिएबल को एक लाइन में int l = p.Length,i = 0, j;

— डिक्लेयर कर सकते हैं

लूप के लिए अपने i++और अपने j--अंदर ले जा सकते हैं । उदाहरण के लिए:for(j=i;j>=0;)if(p[i]==p[j]==(n[i]!=n[j--]))

— अलोयदग का कहना है कि मोनिका

3

रूबी, 63 61 बाइट्स

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

रेगेक्स पैटर्न की खोज करने के बजाय, सभी संभावित तरीकों से 'X', 'Y' और 'Z' को प्रतिस्थापित करने का प्रयास करें, और शाब्दिक मिलान खोजें।

(वास्तव में कारुसोकोम्प्यूटिंग के 05AB1E उत्तर के समान अवधारणा)

— जीबी
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 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

स्निपेट का विस्तार करें

— Arnauld
स्रोत

0

गणित के 18 अक्षर (स्ट्रिंग और पैटर्न की गिनती नहीं)

StringContainsQ[string,pattern]

उदाहरण:

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

True

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

True

— विटाली कौरोव
स्रोत

यह अमान्य है क्योंकि यह स्ट्रिंग और पैटर्न को आवश्यकतानुसार स्ट्रिंग इनपुट के रूप में नहीं लेता है।

— lirtosiast

सरल कोड गोल्फ चुनौती: चरित्र पैटर्न!

उदाहरण

अन्य महत्वपूर्ण / उपयोगी जानकारी

पर्ल 5 , 85 बाइट्स

जेली , 9 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

पायथन 2 , 70 बाइट्स

पायथन 3 , 100 बाइट्स

05AB1E , 19 16 बाइट्स

05AB1E , 14 बाइट्स

जावा 7, 177 176 173 बाइट्स

PHP, 89 बाइट्स

PHP, 105 बाइट्स

PHP, 167 बाइट्स

सी #, 184 165 155 बाइट्स

रूबी, 63 61 बाइट्स

जावास्क्रिप्ट (ईएस 6), 92 89 87 86 बाइट्स

प्रारूपित और टिप्पणी की गई

परीक्षण के मामलों

गणित के 18 अक्षर (स्ट्रिंग और पैटर्न की गिनती नहीं)