क्या यह स्ट्रिंग कार्टव्हील का एक अक्षर है?

35

चुनौती प्रेरणा यह थी कि मैंने कहीं देखा:

शब्द "नन" बस पत्र है n एक गाड़ी का पहिया कर

आपकी चुनौती एक स्ट्रिंग लेने और निर्धारित करने की है कि क्या यह एक कार्टव्हील करने वाला पहला अक्षर है।

नियम

एक स्ट्रिंग एक कार्टव्हील करने वाला एक पत्र है:

  • पहला अक्षर अंतिम अक्षर के समान है। (पत्र उसके सिर पर नहीं जा सकता।)
  • स्ट्रिंग हर एक वर्ण में कार्टव्हीलिंग अक्षरों के बीच वैकल्पिक होता है।

कार्टव्हीलिंग अक्षर हैं nऔर u, mऔर w, bऔर q। ध्यान दें कि nऔर wसाथ में कार्टव्हीलिंग अक्षर नहीं हैं , और न ही हैं wऔर b।

  • आप हमारे किसी भी मानक इनपुट विधि का उपयोग करके एक स्ट्रिंग लेंगे।
  • आप एक सत्य मूल्य का उत्पादन करेंगे यदि स्ट्रिंग एक कार्टव्हीलिंग पत्र है, और एक मिथ्या मूल्य है यदि यह नहीं है। आउटपुट किसी भी मानक आउटपुट विधियों का उपयोग करके किया जा सकता है।

अतिरिक्त नियम:

  • केवल छोटे गाड़ी का पहिया पत्र n/ u/ m/ w/ b/ qजरूरत नियंत्रित किया जा करने के लिए।
  • आप मान सकते हैं कि इनपुट कभी खाली नहीं होता है।
  • एक-वर्ण स्ट्रिंग एक मान्य कार्टव्हील नहीं है।

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

Input        -> Output
nun          -> truthy
nunun        -> truthy
nunununu     -> falsy
wmw          -> truthy
wmwun        -> falsy
bqbqbqbqbqb  -> truthy
v^v^v        -> falsy
AVAVA        -> falsy
OOO          -> falsy
ununununu    -> truthy
nunwmwnun    -> falsy
nun unun     -> falsy
nunwmw       -> falsy
nnuunnuunnuu -> falsy
nwnwnwnwn    -> falsy
m            -> falsy
nunuuunun    -> falsy

विजेता

साथ के रूप में कोड गोल्फ , कम से कम कोड (प्रत्येक भाषा में) जीतता है!

code-golf  string  decision-problem 
— एमडी एक्सएफ
स्रोत
29
मुझे लगता है कि bकार्टव्हील में q, यह नहीं है? dऔर pकार्टव्हील दोस्त भी हैं। वे कुंजी यह है कि वे घूमते हैं, फ्लिप नहीं।
— इंजीनियर टोस्ट
एक और uwuwuwuwuwu
— टेस्टकेस
19
पर क्यों bqbनहीं pdp?
— aschepler
@aschepler मैंने गड़बड़ कर दी।
— एमडी एक्सएफ
2
चूंकि dpd, pdp और इस तरह से काम नहीं करते हैं, मुझे लगता है कि आपको परीक्षण मामलों में उन्हें गलत जवाब देना चाहिए।
— trlkly

जवाबों:

2

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

यह एक से अधिक काम लग सकता है!

“nmbuwq”iЀo⁵IAs2⁼€3,3Ȧ

पात्रों की सूची लेने और लौटने (सच्चाई) 1या 0(फाल्सी) के लिए एक राक्षसी लिंक।

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें।

कैसे?

1-अनुक्रमित वर्णों में इनपुट के प्रत्येक वर्ण के सूचकांक को ढूँढता है nmbuwq। इस स्ट्रिंग की व्यवस्था है ऐसी है कि जोड़े में से अनुक्रमित तीन अलग कर रहे हैं, के रूप में मान्य cartwheels के लिए अनुक्रमित के इस तरह के वृद्धिशील अंतर में से एक की पुनरावृत्ति हो जाएगा [-3,3]या [3,-3]।

जब कोई आइटम परमाणु की "इंडेक्स" द्वारा एक सूची में नहीं iमिलता है 0, तो यह वापस लौटता है , जो कि सत्य की bतरह इनपुट बनाने के साथ निराधार पात्रों को जोड़ेगा bxbxb। इसलिए वैधता की जाँच करने से पहले किसी भी अन्य मूल्य से तीन से अधिक मूल्य के 0बदले एस को बदल दिया जाता 10है।

“nmbuwq”iЀo⁵IAs2⁼€3,3Ȧ - Link: list of characters, s
         Ѐ             - map across c in s:
        i               -   first index of c in (1-indexed; 0 if not present)
“nmbuwq”                -   literal "nmbuwq"
            ⁵           - literal 10
           o            - logical or (vectorises - replace any 0s with 10s)
             I          - incremental differences (i.e. deltas)
              A         - absolute value (vectorises)
               s2       - split into chunks of 2 (possibly with a single remainder)
                   3,3  - pair three with three = [3,3]
                 ⁼€     - equals? for €ach (1 if so, otherwise 0 - including a single 3)
                      Ȧ - any and all? (0 if any 0s or if empty, 1 otherwise)
— जोनाथन एलन
स्रोत
13

sed 4.2.2 , 30 + 1 -r= 43 31 बाइट्स

पहली पंक्ति को छोटा करके @Neil के लिए 12 बाइट्स धन्यवाद सहेजा गया

/nu|wm|qb/!d
/^((.).)\1*\2$/!d

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

यदि गलत है तो इनपुट हटाता है, अन्यथा इनपुट से कुछ भी नहीं होता है।

व्याख्या

साथ -rझंडा, हम उपयोग की जरूरत नहीं है \(और \)समूहों पर कब्जा करने के लिए और इस बाइट्स बचाता है।

/nu|wm|qb/!                # On every line that does not match this regex
           d               # Delete
/^((.).)\1*\2$/!           # On every line that does not math
 ^((.).)                   #  the first two characters at the beginning of the line
        \1*                #  repeated
           \2$             #  with the first character at the end of the line
                d          # Delete
— क्रिकटी लिथोस
स्रोत
यहाँ sedविज़ार्ड आता है ...
— एमडी एक्सएफ
@MDXF मैं एक जादूगर होने से दूर हूं, अभी भी एक शुरुआत
— हूं
sedमेरे लिए सब कुछ मैड्रिड जैसा दिखता है। : पी
— एमडी एक्सएफ
1
आपको केवल अक्षर जोड़े के आधे भाग को शामिल करने के लिए जांचना होगा, जैसे दोनों unuऔर nunहोते हैं nuऔर दूसरी पंक्ति यह सुनिश्चित करती है कि बाकी अक्षर उन दोनों से मेल खाते हैं।
— नील
8

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

ThePirateBay और MD XF द्वारा सुझाए गए दो झूठे मूल्यों का उपयोग करके 1 बाइट को बचाया।

([c,...s],S='bqwmun')=>s.reduceRight((r,a)=>r&a==S[S.search(c)^++k&1],k=s>'')

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
के &&बजाय छोड़ने का कोई कारण &?
@ ThePirateBay खैर, एकमात्र कारण लौटाए गए मिथ्या मूल्य की संगति है, हालांकि यह वास्तव में इस चुनौती के लिए एक आवश्यकता नहीं लगती है। (का उपयोग कर या &तो उत्पादन होगा falseया 0।)
— Arnauld
@ अर्नुलद आप दूसरा हटा सकते हैं &; मैंने निर्दिष्ट (चैट में) कुछ समय के लिए असंगत मिथ्या मूल्यों की अनुमति दी है।
— एमडी एक्सएफ
5

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

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत।

lambda s:s[0]==s[-1]and any(any({*s[::2]}=={i[j]}and{*s[1::2]}=={i[j<1]}for j in[0,1])for i in['nu','mw','bq'])

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

— totallyhuman
स्रोत
2
sighs जैसा कि आप मुझे फिर से पास करते हैं
— MD XF
मुझे यह अच्छा नहीं लग रहा है, क्योंकि आप मेरी बाइट की गिनती फिर से करने वाले हैं, लेकिन -2 बाइट्स ।
— श्री एक्सकोडर
BTW, आपका समाधान अमान्य है, जैसे शुरुआत में मेरा था। के लिए विफल रहता है nunununu।
— श्री एक्सकोडर
बहुत सारे बाइट्स की कीमत पर फिक्स्ड। ; -;
— अमानवीय
5

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

lambda s:s[:3]in'ununqbqbwmwm'and s==s[:2]*max(len(s)/2,1)+s[0]

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

— Harrichael
स्रोत
अच्छा जवाब, साइट पर आपका स्वागत है! कुछ सुझाव: आप "nu un nm mn bp pb".split()4 बाइट्स को बचाने के लिए कर सकते हैं , और आप कुछ व्हाट्सएप को हटा सकते हैं। 75 बाइट्स:lambda s:any(s==c[-1]+c*max(len(s)/2,1)for c in"nu un nm mn bp pb".split())
— DJMcMayhem
के s[0]बजाए आप 1 बाइट बचा सकते हैं c[-1]।
— DJMcMayhem
61 बाइट उत्तर रिटर्न के लिए सही है unmnuऔर unmwnu। (s==s[::-1])+len(set(s))4 साल की उम्र में वास्तव में यह गलत सकारात्मक रिटर्न देता है, जिसे बल देना आसान है। यहां तक ​​कि सिर्फ 4 अलग-अलग किरदार इसे सच कर देते हैं।
— अर्नोल्ड पामर
59 बाइट्स एकल वर्ण इनपुट के साथ टूट जाती हैं। इस एक पर लेने के लिए क्षमा करें, मुझे पायथन पसंद है :)
— अर्नोल्ड पामर
अपवाद नहीं हैं? यह विराम जानबूझकर है
— हरिकेल
5

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

lambda n:''.join(sorted({*n[1::2]}|{*n[::2]}))in"nu,mw,bq"*(n==n[::-1])

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

-1 @HyperNeutrino को धन्यवाद और -13 @ovs को धन्यवाद

यदि उपरोक्त किसी भी परीक्षण के मामले में विफल पाया जाता है, तो एक विकल्प है:

lambda n:(sorted(list({*n[1::2]}.union({*n[::2]})))in[[*'nu'],[*'mw'],[*'bq']])*n[0]==n[-1]

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

व्याख्या

  • ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) - विषम अनुक्रम में वर्ण हो जाता है और यहां तक ​​कि अनुक्रमित पर वर्ण, उन्हें डुप्लिकेट करता है और उनके संघ द्वारा बनाई गई सूची को सॉर्ट करता है।

  • in'nu,mw,bq' - जाँचता है कि क्या वे वैध कार्ट-पत्र संयोजन हैं।

  • n[0]==n[-1] - जाँचता है कि क्या पहला वर्ण अंतिम के समान है।

— मिस्टर एक्सकोडर
स्रोत
कोई परीक्षण मामलों में विफल रहता है, अच्छा काम +1
— एमडी एक्सएफ
@MDXF ओह धन्यवाद! मुझे बहुत राहत मिली है ...> _ <
— श्री एक्सकोडर
1
uwuwuwuwuwuपरिणाम में सच
— Kritii Lithos
1
अमान्य: nunuuunun
— Harrichael
1
nuuun -> True। यह सही नहीं है।
— पुनरावर्ती
5

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

s=>/^(nu|un|bq|qb|wm|mw)+$/.test(s+s[1])

यह देखने के लिए जांचता है कि क्या इनपुट स्ट्रिंग इनपुट स्ट्रिंग के दूसरे वर्ण के साथ समाप्‍त होती है, कार्टव्हील वर्णों की समान जोड़ी का दोहराव वाला स्ट्रिंग है।

टेस्ट:

[
  "nun",
  "nunun",
  "nunununu",
  "wmw",
  "wmwun",
  "bqbqbqbqbqb",
  "v^v^v",
  "AVAVA",
  "OOO",
  "ununununu",
  "nunwmwnun",
  "nun unun",
  "nunwmw",
  "nnuunnuunnuu",
  "nwnwnwnwn",
  "m",
  "nunuuunun"
].forEach( x=>console.log( x, (s=>/^(nu|un|bq|qb|wm|mw)+$/.test(s+s[1]))(x) ) )
स्निपेट का विस्तार करें

— MT0
स्रोत
वास्तव में यहाँ तर्क से प्यार है! मैंने कभी भी अंत और परीक्षण में एक चरित्र जोड़ने के बारे में नहीं सोचा होगा। अच्छा, साफ कोड, भी, जब गोल्फ।
— trlkly
4

क्लोजर, 156 बाइट्स

(fn[w](let[s["nu""wm""bq"]c #(= 1(count(set %)))e #(take-nth 2 %)r #(and(c(e %))(c(e(drop 1 %))))](and(=(first w)(last w))(r w)(some #(=(set w)(set %))s))))

यह भ्रामक मुश्किल था! मैंने इसे 3 उप समस्याओं में तोड़ने के लिए समाप्त किया:

  • क्या पहला अक्षर आखिरी जैसा है?
  • क्या अक्षर दोहराते हैं?
  • क्या सभी पत्र मान्य सेटों में से एक का हिस्सा हैं?

मैं निश्चित रूप से नहीं जीता, लेकिन यह एक अच्छा सुबह व्यायाम था! नीचे पूर्ण विवरण:

(defn cartwheel? [word]
  (let [; Valid Character Sets
        cs ["nu" "wm" "bq"]

        ; Is the list composed of only a single character?
        count-1? #(= 1 (count (set %)))

        ; Grabs every other element of the list
        every-other #(take-nth 2 %)

        ; Do the characters repeat? Works by checking if every other element is the same, then drops the first letter
        ; to check all the odd indexed characters
        repeating? #(and (count-1? (every-other %))
                         (count-1? (every-other (drop 1 %))))]

    ; Do all the predicates hold?
    (and (= (first word) (last word))
         (repeating? word)
         ; Is the set of letters in the word part of some set of the valid characters?
         (some #(= (set word) (set %)) cs))))
— Carcigenicate
स्रोत
4

हास्केल, 80 78 बाइट्स

f s|l<-length s=odd l&&l>1&&any((==s).take l.cycle)(words"un nu mw wm bq qb")

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

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

l<-length s        -- let l be the length of the input string

f s         =      -- return True, if
    odd l          -- l is odd and
    l > 1          -- l is greater than 1 and 
    any            -- any of the following is also True
      (     )(words "  ...  ")
                   -- apply the function to each of the words "un", "nu" ... "qb"
           cycle   --  infinitely repeat the word
      take l       --  take the first l characters
     (==s)         --  and compare to s
— nimi
स्रोत
4

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

lambda s:s[2:]+s[1:3]==s>s[:2]in'bqbunuwmw'

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

स्ट्रिंग में रिक्त स्थान DELवर्ण हैं।

— XNOR
स्रोत
|u|की व्याख्या कार्टव्हील के रूप में की जाती है।
— हरिकेल
@ हैरिकेल मैं DELस्पष्ट होने के लिए पात्रों में रखता हूं ।
— xnor
DEL वर्ण अभी भी इनपुट वर्ण हो सकते हैं। मैं अपने समाधान चाहते हैं, लेकिन आप मेरा उत्तर से एक चाल उधार चाहिए:s[:3]in'bqbqnunuwmwm'
— Harrichael
4

रेटिना , 24 बाइट्स

G`nu|mw|bq
^((.).)\1*\2$

सत्य के लिए आउटपुट 1, मिथ्या के लिए 0।

पोर्ट ऑफ कॉज का जवाब।

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

— Okx
स्रोत
नया संस्करण सत्य के लिए nunwmwnun(जब यह गलत होना चाहिए) के लिए आउटपुट देता है , यही कारण है कि मेरे पास \1*मेरे sed उत्तर में था।
— क्रिति लिथोस
@Cowsquack आह मैं देख रहा हूँ।
— ओकेक्स
पहली पंक्ति तब से हो सकती है G`nu|mw|bpजब सभी सत्य तार में एक अक्षर जोड़े होते हैं और दूसरी पंक्ति यह सुनिश्चित करती है कि बाकी सभी स्ट्रिंग में वे अक्षर भी हों ..
— नील
@ नील वह परीक्षण मामले में विफल रहता हैununununu
— ओकेएक्स
@ ओक्स नील का सुझाव अभी भी उस टेस्टकेस के लिए काम करने लगता है इसे ऑनलाइन आज़माएं!
— क्रिति लिथोस
3

पीस , 28 बाइट्स

e`..-#!"nu\|bq\|mw"oTv&..v+.

इसे ऑनलाइन आज़माएं! 1सत्य आदानों के लिए और 0झूठे लोगों के लिए प्रिंट ।

व्याख्या

जमीनी वाक्यविन्यास नियमित अभिव्यक्तियों से मिलता-जुलता है, और एक जमीनी कार्यक्रम एक पैटर्न को निर्दिष्ट करता है जो वर्णों की आयत से मेल खा सकता है या नहीं।

e`..-#!"nu\|bq\|mw"oTv&..v+.
e`                            Match input against pattern:
      !                       Does not
     #                        contain
  ..                          a 2-character substring
    -                         which is not
       "nu\|bq\|mw"           any of these strings
                   oT         potentially reversed,
                     v&       AND
                       ..     two characters
                         v+   one or more times
                           .  then one more character.

ग्रिम की कुछ विशेषताएं जिन्होंने इसे छोटा करने में मदद की:

  • आम तौर पर एक चरित्र शाब्दिक बैकस्लैश के साथ बच जाना चाहिए, लेकिन "" परिवर्तन होता है: वाक्यविन्यास तत्व बच जाते हैं लेकिन शाब्दिक नहीं हैं। उद्धरण के बिना, जो चरित्र पात्रों की गणना करता है वह हिस्सा होगा (\n\u|\b\p|\m\w)oT।
  • एक बाइनरी ऑपरेटर (यहां -) का पालन करने वाले यूनिरी ऑपरेटर इसके परिणाम पर कार्य करते हैं: ..-#!"…"oTके बराबर है(..-"…"oT)#! ।
  • vरों वाक्यविन्यास तत्वों है कि उन्हें पालन की पूर्वता कम। एक लोन &की तुलना में अधिक पूर्वता है -, लेकिन v&कम है। इसी तरह, के ..+रूप में पार्स किया जाता है .(.+), लेकिन ..v+इसके बराबर है (..)+।
— Zgarb
स्रोत
2

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

Ḋm2Qµ³m2Q;Ṣe“nu“mw“bq”ȧ³⁼U¤

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

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

Ḋm2Qµ³m2Q;µṢe“nu“mw“bq”ȧ³⁼U¤  Main link; z is the argument
Ḋ                             z[1:]
 m2                           z[1::2]
   Q                          deduplicate(z[1::2])
    µ                         New Chain
     ³                        z
      m2                      z[::2]
        Q                     deduplicate(z[::2])
         ;                    deduplicate(z[1::2]) + deduplicate(z[::2])
          Ṣ                  Sort the result
           e                 Is it an element of the following?
            “nu“mw“bq”       ["nu", "mw", "bq"]
                      ȧ      It has the correct characters and:
                       ³  ¤  Nilad followed by links as nilad
                       ³     z
                        ⁼      == 
                         U        z[::-1]
                          ¤  [End chain]
— HyperNeutrino
स्रोत
जेली ... अजगर से अधिक लंबा ?!
— श्री एक्सकोडर
@ Mr.Xcoder shhhh मैं इस पर काम कर रहा हूं ... xD
— HyperNeutrino
Hah अच्छी तरह से मैं अब आपके साथ xD
— HyperNeutrino
2

जाप , 47 बाइट्स

g ¦U¬o ª`q¿nwm`ò má c aU¯2)<0?0:UÅë ä¥ ©Uë ä¥ e

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

— ओलिवर
स्रोत
क्या आप किसी भी बाइट को बचाने के लिए स्ट्रिंग को संपीड़ित कर सकते हैं?
— शगि
nwnwn सच है जब यह असत्य है
— हरिकेल
@ हेरिकेल धन्यवाद, निश्चित!
— ओलिवर
1

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

lambda x:[len(x)%2,x[:2]in'nu,un,bq,qb,mw,wm',len(set(x[::2])),len(set(x[1::2]))]==[1]*4

len(x)%2: एक समान लंबाई वाला स्ट्रिंग पहले वर्ण पर समाप्त नहीं हो सकता

x[:2] in: 6 मान्य शुरुआत जोड़े में से किसी के लिए जाँच करें

len(set()): 0,2,4 ... और 1,3,5 पर वर्णों के सेट की लंबाई प्राप्त करें ...

Trueयदि मूल्यांकन की सूची [1,1,1,1] के बराबर है, तो वापस लौटाता है False।

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

— nocturama
स्रोत
1

पर्ल 5 , 55 + 1 (-पी) = 56 बाइट्स

$c={"nuunmwwmbppb"=~/./g}->{$l=chop};$_=/^($l$c)+$/&&$c

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

सच के लिए पहले चरित्र के "उल्टा" संस्करण प्रिंट करता है, झूठे के लिए कुछ भी नहीं।

— Xcali
स्रोत
मुझे एक ठोस 18 बाइट्स से हराया। अच्छा जवाब!
— सिल्वियो मायोलो
अभी तो बहुत नहीं। मूल सभी समान वर्ण के किसी भी स्ट्रिंग के लिए सही लौट रहा था।
— Xcali
1

PHP, 59 + 1 बाइट्स

<?=preg_match('#^(nu|un|mw|wm|bq|qb)\1+$#',$argn.$argn[1]);

साथ पाइप के रूप में चलाएँ -F ।

आंशिक रूप से रेगेक्स समाधान, 101 + 1 बाइट्स:

for($s=$argn;$c=$s[$i++];$p=$c)$c!=$p||die;echo$i%2<1&&preg_match("#^(nu|mw|bq)#",count_chars($s,3));

झूठा के लिए खाली उत्पादन। साथ पाइप के रूप में चलाएँ -nR।

— टाइटस
स्रोत
1

जावा 8, 57 बाइट्स

s->s.matches("(nu)+n|(un)+u|(mw)+m|(wm)+w|(bq)+b|(qb)+q")

इसे यहाँ आज़माएँ।

सभी छह मामलों का मिलान करने के लिए सरल रीगेक्स। ध्यान दें कि जावा String#matchesस्वचालित रूप से पूरे स्ट्रिंग से मेल खाता है, इसलिए इसकी कोई आवश्यकता नहीं है ^...$।

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

MATL , 25 बाइट्स

'nuwmbq'&mq2&\d~wdts~Gnqv

Ouput एक गैर-खाली संख्यात्मक कॉलम वेक्टर है, जो सत्य है यदि इसकी सभी प्रविष्टियाँ नॉनज़रो हैं , और मिथ्या अन्यथा। इसे ऑनलाइन आज़माएं!

सभी परीक्षण मामलों को सत्यापित करने के लिए , ifपाद में एक शाखा जोड़ी जाती है जो स्ट्रिंग द्वारा किसी भी सत्य मान को प्रतिस्थापित करती है 'truthy', या स्ट्रिंग द्वारा किसी भी गलत मूल्य को 'falsy'दर्शाती है, और फिर स्ट्रिंग प्रदर्शित करती है।

व्याख्या

'nuwmbq'  % Push this string
&m        % Implicit input. For each char, push index of membership in the above
          %  string, or 0 if not member
q         % Subtract 1
2         % Push 2
&\        % Divmod. Pushes remainders, then quotients
d~        % Consecutive differences negated. Gives an array of ones iff all
          % quotients were equal
w         % Swap. Moves remainders to top
d         % Consecutive differences. Gives nonzeros iff no consecutive
          % remainders were equal
ts~       % Duplicate, sum, negate. Gives true iff sum was 0. For unequal
          % consecutive differences of remainders, this corresponds to an odd
          % number of remainders
Gnq       % Push input, length, subtract 1. True iff input longer than 1
v         % Concatenate into column vector. Truthy iff all entries are nonzero
— लुइस मेंडो
स्रोत
0

क्लोजर, 115 बाइट्स

(apply some-fn(map(fn[r]#(re-matches r %))(map(fn[[x y]](re-pattern(str x"("y x")+")))["nu""un""mw""wm""bq""qb"])))

प्रत्येक अक्षर जोड़ी से एक रेगेक्स बनाएँ और देखें कि क्या इनपुट एक से मेल खाता है। इन सभी भागों को करने के लिए और अधिक सुरुचिपूर्ण तरीके हैं, लेकिन वे सभी अधिक क्रियाशील हैं। क्लोजुर गोल्फिंग के साथ ऐसा जीवन है।

— MattPutnam
स्रोत
0

पर्ल 5, 68 + 1 = 69 बाइट्स

if(/../&&$&=~/nu|un|bq|qb|mw|wm/){s/^($&)*//;$&=~/./;print if/^$&$/}

साथ दौड़ो -n ।

स्पष्टीकरण:

# Match the first two characters, and if they exist, then...
if (/../ &&
 # Make sure they are a pair of compatible cartwheel characters.
 $&=~/nu|un|bq|qb|mw|wm/) {
  # If that's true, then eliminate as many of that pair of characters
  # from the beginning of the string as possible.
  s/^($&)*//;
  # Then get the first character out of the match (the first character
  # of the original string).
  $&=~/./;
  # Print the text (which is truthy since it's nonempty) if the original
  # first character matches exactly the remaining string.
  print if/^$&$/
  # Otherwise, print nothing (the empty string in Perl is falsy).
}
— सिल्वियो मायोलो
स्रोत
0

TXR लिस्प , 50 बाइट्स

(f^$ #/n(un)+|u(nu)+|m(wm)+|w(mw+)|b(qb)+|q(bq)+/)

चलाएँ:

1> (f^$ #/n(un)+|u(nu)+|m(wm)+|w(mw+)|b(qb)+|q(bq)+/)
#<intrinsic fun: 1 param>
2> [*1 "nun"]
"nun"
3> [*1 "nuns"]
nil
4> [*1 "mwm"]
"mwm"
5> [*1 "wmw"]
"wmw"
6> [*1 "abc"]
nil

f^$एक कॉम्बिनेटर है जो रेगेक्स ऑब्जेक्ट लेता है और एक फ़ंक्शन देता है जो एंकर तरीके से उस रेगेक्स से मेल खाता है। (अपने आप में, एक रेगेक्स ऑब्जेक्ट फ़ंक्शन-कॉल करने योग्य ऑब्जेक्ट है जो एक स्ट्रिंग लेता है और इसके माध्यम से अपने लिए खोज करता है।)

— Kaz
स्रोत
0

TXR : 78 74 बाइट्स

@{x 2}@(rep :gap 0)@x@(end)@y
@(bind(x y)(#"nu un mw wm bq qb"@[x 0..1]))

भागो, सिस्टम प्रॉम्प्ट से। संकेत में संख्या समाप्ति की स्थिति है: 0 = सफलता, 1 = विफलता:

0:$ ./txr cart.txr 
nun
0:$ ./txr cart.txr 
abc
1:$ ./txr cart.txr 
bab
1:$ ./txr cart.txr 
mwm
1:$ ./txr cart.txr 
nununununun
0:$

स्पष्टीकरण:

  • @{x 2}: दो वर्णों का मिलान करें, xचर से बांधें ।
  • @(rep :gap 0)@x@(end): बिना स्किप किए हुए अंतराल के साथ दोहराया जाने वाला मैच: शून्य या उससे अधिक की घटनाएँ x, पहले से खोदे गए मिलान।
  • @y: मिलान की गई शेष रेखा, पर कब्जा कर लिया गया y।
  • @(bind(x y)(foo bar)): बाइ , xटू foo, वाई टू bar। के बाद से xऔर yपहले से ही बाध्य कर रहे हैं, वे मैच के लिए है fooऔर bar, वरना वहाँ एक विफलता है।
  • fooहै #"nu un mw wm bq qb", एक शब्द सूची शाब्दिक, लिस्प सूची के लिए वाक्यात्मक चीनी ("nu" "un" ... "qb")। एक bindचर और एक सूची के बीच मेल का मतलब है कि चर को एक तत्व से मेल खाना चाहिए।
  • barहै @[x 0..1]: xअपनी शुरुआत से एक-चरित्र का विकल्प । bindबीच का मैच yऔर यह लाइन के आखिरी अक्षर को पहले मैच के लिए मजबूर करता है।
— Kaz
स्रोत
0

सी ++, 268 बाइट्स

#include<map>
#include<string>
std::map<char,char>c{{'n','u'},{'m','w'},{98,'q'},{'w','m'},{'u','n'},{'q',98}};
int w(std::string s){if(s[0]!=s[s.size()-1]||c.find(s[0])==c.end()||s.size()<3)return 0;for(int i=0;i<s.size()-1;i+=2)if(s[i+1]!=c[s[i]])return 0;return 1;}
— HatsuPointerKun
स्रोत
केवल दो के बजाय सभी वर्णों के लिए ASCII मानों का उपयोग करके 10 बाइट्स सहेजें ।
— एमडी एक्सएफ
@MDXF n= 110, u= 117, m= 109, w= 119, q= 113. इसलिए ASCII मूल्यों का उपयोग करना या इससे अधिक किसी भी वर्ण के लिए कोई फर्क नहीं पड़ता c(99)
— HatsuPointerKun
0

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

s=>/bq|wm|un/.test(s)&s.replace(RegExp(s[0]+s[1],'g'),'')==s[0]

लौटाता है 1या 0।

व्याख्या

सभी कार्टव्हील तार में एक या एक से अधिक बीसी , डब्ल्यूएम , या संयुक्त राष्ट्र होंगे । हम इसके लिए परीक्षण करते हैं:

/bq|wm|un/.test(s)

यदि आप कार्टव्हील स्ट्रिंग के पहले दो अक्षरों के सभी उदाहरणों को कुछ नहीं के साथ बदलते हैं, तो आपको स्ट्रिंग के पहले अक्षर के साथ छोड़ दिया जाता है। हम इसके लिए परीक्षण करते हैं:

s.replace(RegExp(s[0]+s[1],'g'),'')==s[0]

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.