แรงบันดาลใจท้าทายคือสิ่งที่ฉันเห็นที่ไหนสักแห่ง:

คำว่า "แม่ชี" เป็นเพียงตัวอักษรnกำลังทำกงล้อ

ความท้าทายของคุณคือการใช้สายและตรวจสอบว่ามันเป็นตัวอักษรตัวแรกที่ทำล้อ

กฎระเบียบ

สตริงเป็นตัวอักษรที่ทำล้อเลียนถ้า:

• ตัวอักษรตัวแรกเหมือนกับตัวอักษรตัวสุดท้าย (จดหมายไม่สามารถตกลงบนหัวของมันได้)
• สตริงจะสลับระหว่างตัวอักษรของวงล้อหมุนทุกตัวละครหนึ่งตัว

ตัวอักษร cartwheeling มีnและu, mและw, และb qโปรดทราบว่าnและwร่วมกันไม่ได้ cartwheeling ตัวอักษรและไม่เป็นและwb

• คุณจะใช้สายอักขระโดยใช้วิธีการอินพุตมาตรฐานของเรา
• คุณจะส่งออกค่าความจริงหากสตริงเป็นตัวอักษรการหมุนวนและค่าเท็จถ้าไม่ได้ เอาต์พุตสามารถทำได้โดยใช้วิธีเอาต์พุตมาตรฐานใด ๆ

กฎเพิ่มเติม:

• เฉพาะอักษรตัวพิมพ์เล็กกงเกวียน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รหัสที่สั้นที่สุด (ในแต่ละภาษา) ชนะ!

เยลลี่ 23 ไบต์

_{ใช้เวลาทำงานมากกว่าที่คิด!}

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

ลิงก์ monadic ที่รับรายการอักขระและส่งคืน1(ความจริง) หรือ0(เท็จ)

ลองออนไลน์! หรือดูชุดทดสอบ

อย่างไร?

พบว่าดัชนีของตัวละครของท่านแต่ละคนในรายการที่ 1 nmbuwqการจัดทำดัชนีของตัวละคร ข้อความนี้ถูกจัดดังกล่าวว่าดัชนีของคู่สามออกจากกันเช่นความแตกต่างที่เพิ่มขึ้นของดัชนีสำหรับตีลังกาที่ถูกต้องจะเป็นซ้ำของหนึ่งหรือ[-3,3][3,-3]

เมื่อไม่พบรายการในรายการโดย "ดัชนีของ" อะตอมiจะส่งคืน0ซึ่งจะจับคู่อักขระที่ไม่มีส่วนร่วมด้วยbทำให้อินพุตเหมือนbxbxbจริง ดังนั้น0s จะถูกแทนที่ด้วย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)

sed 4.2.2 , 30 + 1 -r= 43 31 ไบต์

บันทึก 12 ไบต์ด้วย @Neil โดยย่อบรรทัดแรก

/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

JavaScript (ES6), 82 78 77 ไบต์

บันทึก 1 ไบต์โดยใช้ค่าเท็จสองค่าตามที่แนะนำโดย ThePirateBay และ MD XF

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

กรณีทดสอบ

let f =

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

console.log('Truthy ...')
console.log(f("nun"         )) // -> truthy
console.log(f("nunun"       )) // -> truthy
console.log(f("wmw"         )) // -> truthy
console.log(f("bqbqbqbqbqb" )) // -> truthy
console.log(f("ununununu"   )) // -> truthy

console.log('Falsy ...')
console.log(f("nunununu"    )) // -> falsy
console.log(f("wmwun"       )) // -> falsy
console.log(f("v^v^v"       )) // -> falsy
console.log(f("AVAVA"       )) // -> falsy
console.log(f("OOO"         )) // -> falsy
console.log(f("nunwmwnun"   )) // -> falsy
console.log(f("nun unun"    )) // -> falsy
console.log(f("nunwmw"      )) // -> falsy
console.log(f("nnuunnuunnuu")) // -> falsy
console.log(f("m"           )) // -> falsy

Python 3 , 111 ไบต์

-2 ไบต์ขอบคุณ Mr. Xcoder

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

ลองออนไลน์!

Python 2 , 63 ไบต์

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

ลองออนไลน์!

Python 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] - ตรวจสอบว่าอักขระตัวแรกเหมือนกับตัวอักษรตัวสุดท้ายหรือไม่

JavaScript (ES6), 40 ไบต์

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

ตรวจสอบเพื่อดูว่าสตริงอินพุตที่ต่อกับอักขระตัวที่สองของสตริงอินพุตนั้นเป็นสตริงที่ซ้ำกันของอักขระ cartwheel คู่เดียวกัน

แบบทดสอบ:

[
  "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) ) )

Clojure, 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))))

Haskell, 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

Python 2 , 45 ไบต์

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

ลองออนไลน์!

ช่องว่างในสตริงเป็นDELอักขระ

เรติน่า 24 ไบต์

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

เอาต์พุต 1 สำหรับความจริง, 0 สำหรับความเท็จ

คำตอบของ Port of Cows นักต้มตุ๋น

ลองออนไลน์!

สิ่งสกปรก 28 ไบต์

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

ลองออนไลน์! พิมพ์1สำหรับอินพุตที่เป็นความจริงและ0สำหรับคนที่เป็นเท็จ

คำอธิบาย

ไวยากรณ์ Grime คล้ายกับนิพจน์ทั่วไปและโปรแกรม Grime ระบุรูปแบบที่อาจหรือไม่ตรงกับรูปสี่เหลี่ยมผืนผ้าของอักขระ

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.

คุณสมบัติบางอย่างของ Grime ที่ช่วยย่อเรื่องนี้:

• โดยปกติแล้วตัวอักษรจะต้องหลบหนีด้วยแบ็กสแลช แต่""การเปลี่ยนแปลงนี้: องค์ประกอบไวยากรณ์จะหลบหนี แต่ตัวอักษรไม่ได้ หากไม่มีเครื่องหมายอัญประกาศส่วนที่ระบุคู่อักขระจะเป็น(\n\u|\b\p|\m\w)oTส่วนที่ระบุคู่ตัวละครตัวนี้จะเป็น
• ผู้ประกอบการที่เป็นไปตามเอกผู้ประกอบการไบนารี (ที่นี่-) การกระทำกับผลของมันจะเทียบเท่ากับ..-#!"…"oT(..-"…"oT)#!
• vs ลดความสำคัญขององค์ประกอบไวยากรณ์ที่เป็นไปตามพวกเขา โดดเดียว&มีความสำคัญสูงกว่า-แต่v&ต่ำกว่า ในทำนองเดียวกัน..+จะแยกเป็น.(.+)แต่เทียบเท่ากับ..v+(..)+

Python 2 , 69 ไบต์

lambda x:any([x in p*len(x)for p in'nu','mw','bq'])*len(x)%2*len(x)>2

ลองออนไลน์!

Pyth , 27 ไบต์

&qeQhQ/"nu,mw,bq"S+{%2tQ{%2

ชุดทดสอบ

เอาต์พุต1สำหรับความจริงและFalseหรือ0เป็นเท็จเนื่องจาก OP อนุญาตในการแชท

เยลลี่ , 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]

Python 2 , 103 ไบต์

lambda x:len(x)>1and{x[0],x[1]}in[{i,j}for i,j in zip('ubw','nqm')]and x==(-~len(x)/2*(x[0]+x[1]))[:-1]

ลองออนไลน์!

Japt , 47 ไบต์

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

ลองออนไลน์!

Python 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อื่น

ลองออนไลน์!

Perl 5 , 55 + 1 (-p) = 56 ไบต์

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

ลองออนไลน์!

พิมพ์เวอร์ชัน "คว่ำลง" ของอักขระตัวแรกเป็น true ไม่มีอะไรเป็นเท็จ

PHP, 59 + 1 ไบต์

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

-Fทำงานเป็นท่อด้วย

โซลูชัน regex บางส่วน 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ทำงานเป็นท่อด้วย

Java 8, 57 ไบต์

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

ลองที่นี่

regex ง่ายเพื่อให้ตรงกับทั้งหกกรณี โปรดทราบว่า Java เป็นโดยอัตโนมัติตรงกับทั้งสตริงดังนั้นจึงไม่มีความจำเป็นที่จะต้องString#matches^...$

MATL , 25 ไบต์

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

ouput เป็นไม่ว่างเปล่าเวกเตอร์คอลัมน์ตัวเลขซึ่งเป็นtruthyหากทุกรายการที่มีเลขและfalsyมิฉะนั้น ลองออนไลน์!

เพื่อตรวจสอบกรณีทดสอบทั้งหมดเป็นifสาขาที่มีการเพิ่มในส่วนท้ายที่มาแทนที่ค่า truthy ใด ๆ โดยสตริง'truthy'หรือค่า falsy ใด ๆ โดยสตริง'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

Python 2 , 74 ไบต์

import re
re.compile('(n(un)+|u(nu)+|m(wm)+|w(mw)+|b(pb)+|p(bp)+)$').match

ลองออนไลน์! สิ่งนี้ทำให้ปัญหามีการแข่งขันที่น่าประหลาดใจ

Clojure 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"])))

สร้าง regex จากคู่ตัวอักษรแต่ละตัวและดูว่าอินพุตตรงกันหรือไม่ มีวิธีที่สง่างามกว่านี้ในการทำส่วนต่าง ๆ เหล่านี้ทั้งหมด นั่นคือชีวิตกับการเล่นกอล์ฟ Clojure

Perl 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).
}

TXR Lisp , 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^$คือ combinator ซึ่งรับอ็อบเจกต์ regex และส่งคืนฟังก์ชันที่ตรงกับเรกซ์นั้นในลักษณะที่ยึด (โดยตัวมันเองวัตถุ regex เป็นวัตถุที่เรียกฟังก์ชันได้ซึ่งใช้สตริงและค้นหาตัวมันเอง)

Python 3 , 66 ไบต์

lambda x:x==len(x)//2*x[:2]+x[0]and{*x}in[{*'nu'},{*'mw'},{*'bq'}]

ลองออนไลน์!

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, y barไป ตั้งแต่xและyมีการผูกไว้แล้วพวกเขาจะต้องจับคู่fooและbarหรืออื่น ๆ ที่มีความล้มเหลว
• fooคือ #"nu un mw wm bq qb"เป็นตัวอักษรรายการคำ, ("nu" "un" ... "qb")น้ำตาลประโยคสำหรับรายการเสียงกระเพื่อม bindจับคู่ระหว่างตัวแปรและรายการหมายความว่าตัวแปรนั้นจะต้องตรงกับองค์ประกอบ
• barคือ@[x 0..1]: สตริงย่อยหนึ่งอักขระของxจากจุดเริ่มต้น การbindจับคู่ระหว่างyและบังคับให้อักษรตัวสุดท้ายของบรรทัดตรงกับตัวแรก

C ++, 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;}

JavaScript (ES6), 63 ไบต์

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

ผลตอบแทน 10หรือ

คำอธิบาย

สายอักขระของวงล้อทั้งหมดจะมีbq , wmหรือunอย่างน้อยหนึ่งรายการ เราทดสอบด้วย:

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

หากคุณแทนที่ตัวอักษรสองตัวแรกของสตริง cartwheel ทั้งหมดโดยไม่มีอะไรคุณจะเหลือตัวอักษรตัวแรกของสตริง เราทดสอบด้วย:

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

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

console.log(f('nun'))          // truthy
console.log(f('nunun'))        // truthy
console.log(f('nunununu'))     // falsy
console.log(f('wmw'))          // truthy
console.log(f('wmwun'))        // falsy
console.log(f('bqbqbqbqbqb'))  // truthy
console.log(f('v^v^v'))        // falsy
console.log(f('AVAVA'))        // falsy
console.log(f('OOO'))          // falsy
console.log(f('ununununu'))    // truthy
console.log(f('nunwmwnun'))    // falsy
console.log(f('nun unun'))     // falsy
console.log(f('nunwmw'))       // falsy
console.log(f('nnuunnuunnuu')) // falsy
console.log(f('nwnwnwnwn'))    // falsy
console.log(f('m'))            // falsy