Cảm hứng thử thách là điều mà tôi thấy ở đâu đó:

Từ "nữ tu" chỉ là chữ n đang làm một chiếc xe đẩy

Thử thách của bạn là lấy một chuỗi và xác định xem đó có phải là chữ cái đầu tiên thực hiện cartwheel không.

Quy tắc

Một chuỗi là một chữ cái làm một cartwheel nếu:

• Chữ cái đầu tiên giống như chữ cái cuối cùng. (Bức thư không thể hạ cánh trên đầu của nó.)
• Chuỗi xen kẽ giữa các chữ cái cartwheeling mỗi một ký tự.

Các chữ cartwheeling là nvà u, mvà w, bvà q. Lưu ý rằng nvà wcùng nhau không phải là chữ cái sụn, và cũng không wvà b.

• Bạn sẽ lấy một chuỗi bằng bất kỳ phương thức nhập liệu tiêu chuẩn nào của chúng tôi.
• Bạn sẽ xuất ra một giá trị trung thực nếu chuỗi là một chữ cái cartwheeling và một giá trị giả nếu nó không phải là. Đầu ra có thể được thực hiện bằng cách sử dụng bất kỳ phương pháp đầu ra tiêu chuẩn.

Quy tắc bổ sung:

• Chỉ cần viết các chữ cái bánh xe n/ u/ m/ w/ b/ q.
• Bạn có thể cho rằng đầu vào không bao giờ trống.
• Chuỗi một ký tự không phải là một cartwheel hợp lệ.

Các trường hợp thử nghiệm

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

Người chiến thắng

Cũng như code-golf , mã ngắn nhất (trong mỗi ngôn ngữ) sẽ thắng!

Thạch , 23 byte

_{Điều này mất nhiều công sức hơn người ta có thể nghĩ!}

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

Một liên kết đơn âm lấy một danh sách các nhân vật và trở về 1(trung thực) hoặc 0(falsey).

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm .

Làm sao?

Tìm chỉ mục của từng ký tự của đầu vào trong danh sách 1 ký tự được lập chỉ mục nmbuwq. Chuỗi này được sắp xếp sao cho các chỉ mục của các cặp cách nhau ba lần, do đó, sự khác biệt gia tăng của các chỉ mục cho các giỏ hàng hợp lệ sẽ là sự lặp lại của một trong [-3,3]hoặc [3,-3].

Khi một mục "không được tìm thấy trong một danh sách bởi nguyên tử" chỉ mục của " i, nó sẽ trả về 0, nó sẽ ghép các ký tự không có căn cứ với nhau b, làm cho đầu vào giống như sự bxbxbthật. Vì vậy, 0s được thay thế bằng 10một giá trị hơn ba so với bất kỳ giá trị nào khác trước khi kiểm tra tính hợp lệ.

“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 byte

Đã lưu 12 byte nhờ @Neil bằng cách rút ngắn dòng đầu tiên

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

Hãy thử trực tuyến!

Xóa đầu vào nếu falsey, nếu không thì không có gì với đầu vào.

Giải trình

Với -rcờ, chúng ta không cần sử dụng \(và \)để bắt các nhóm và điều này giúp tiết kiệm byte.

/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 byte

Đã lưu 1 byte bằng cách sử dụng hai giá trị giả, như được đề xuất bởi ThePirateBay và MD XF.

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

Các trường hợp thử nghiệm

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 byte

-2 byte nhờ ông 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'])

Hãy thử trực tuyến!

Python 2 , 63 byte

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

Hãy thử trực tuyến!

Python 3 , 71 byte

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

Hãy thử trực tuyến!

-1 cảm ơn @HyperNeutrino và -13 cảm ơn @ovs

Nếu phát hiện ở trên không thành công cho bất kỳ trường hợp thử nghiệm nào, có một cách khác:

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

Hãy thử trực tuyến!

Giải trình

• ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) - Nhận các ký tự ở các chỉ mục lẻ và các ký tự ở các chỉ mục chẵn, sao chép lại chúng và sắp xếp danh sách được tạo bởi liên minh của chúng.

• in'nu,mw,bq' - Kiểm tra nếu chúng là kết hợp giỏ hàng chữ cái hợp lệ.

• n[0]==n[-1] - Kiểm tra xem ký tự đầu tiên có giống ký tự cuối không.

JavaScript (ES6), 40 byte

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

Kiểm tra xem chuỗi đầu vào được nối với ký tự thứ hai của chuỗi đầu vào có phải là chuỗi lặp lại của cùng một cặp ký tự cartwheel không.

Các xét nghiệm:

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

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

Điều này thật khó hiểu! Cuối cùng tôi đã chia nó thành 3 vấn đề phụ:

• Là chữ cái đầu tiên giống như cuối cùng?
• Các chữ cái có lặp lại không?
• Có phải tất cả các chữ cái là một phần của một trong các bộ hợp lệ?

Tôi chắc chắn đã không chiến thắng, nhưng đây là một bài tập thể dục buổi sáng tốt! Giải thích đầy đủ dưới đây:

(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 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

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 byte

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

Hãy thử trực tuyến!

Các khoảng trắng trong chuỗi là các DELký tự.

Võng mạc , 24 byte

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

Đầu ra 1 cho sự thật, 0 cho giả.

Câu trả lời của cảng bò.

Hãy thử trực tuyến!

Vết bẩn , 28 byte

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

Hãy thử trực tuyến! In 1cho đầu vào trung thực và 0cho những người giả mạo .

Giải trình

Cú pháp Grime giống với các biểu thức thông thường và chương trình Grime chỉ định một mẫu có thể hoặc không khớp với hình chữ nhật của các ký tự.

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.

Một số tính năng của Grime đã giúp rút ngắn điều này:

• Thông thường, một ký tự phải được thoát bằng dấu gạch chéo ngược, nhưng ""thay đổi điều này: các thành phần cú pháp được thoát nhưng nghĩa đen thì không. Nếu không có dấu ngoặc kép, phần liệt kê các cặp ký tự sẽ là(\n\u|\b\p|\m\w)oT .
• Các toán tử đơn nguyên tuân theo toán tử nhị phân (ở đây -) hành động theo kết quả của nó: ..-#!"…"oTtương đương với (..-"…"oT)#!.
• Các vs thấp hơn ưu tiên của các yếu tố cú pháp theo sau chúng. Một đơn độc &có quyền ưu tiên cao hơn -, nhưng v&có thấp hơn. Tương tự, ..+được phân tích cú pháp như .(.+), nhưng ..v+tương đương với (..)+.

Python 2 , 69 byte

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

Hãy thử trực tuyến!

Bình thường , 27 byte

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

Phòng thử nghiệm.

Đầu ra 1cho sự thật và Falsehoặc giả 0, như OP cho phép trong trò chuyện.

Thạch , 27 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ḋ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 byte

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]

Hãy thử trực tuyến!

Japt , 47 byte

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

Hãy thử trực tuyến!

Python 3 , 88 byte

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: một chuỗi có độ dài chẵn không thể kết thúc ở ký tự đầu tiên

x[:2] in: kiểm tra bất kỳ trong số 6 cặp bắt đầu hợp lệ

len(set()): lấy chiều dài của các bộ ký tự ở mức 0,2,4 ... và 1,3,5 ...

Trả về Truenếu danh sách các đánh giá bằng [1,1,1,1], khác False.

Hãy thử trực tuyến!

Perl 5 , 55 + 1 (-p) = 56 byte

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

Hãy thử trực tuyến!

In phiên bản "lộn ngược" của ký tự đầu tiên cho đúng, không có gì sai.

PHP, 59 + 1 byte

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

Chạy như ống với -F.

giải pháp regex một phần, 101 + 1 byte:

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

Đầu ra trống cho giả. Chạy như ống với -nR.

Java 8, 57 byte

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

Hãy thử nó ở đây.

Regex đơn giản để phù hợp với tất cả sáu trường hợp. Lưu ý rằng Java String#matchestự động khớp với toàn bộ Chuỗi, do đó không cần ^...$.

MATL , 25 byte

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

Ouput là một vectơ cột số không trống, điều này là sự thật nếu tất cả các mục nhập của nó là khác không và giả mạo khác. Hãy thử trực tuyến!

Để xác minh tất cả các trường hợp kiểm tra , một ifnhánh được thêm vào chân trang thay thế bất kỳ giá trị trung thực nào bằng chuỗi 'truthy'hoặc bất kỳ giá trị giả nào của chuỗi 'falsy', sau đó hiển thị chuỗi.

Giải trình

'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 byte

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

Hãy thử trực tuyến! Điều này có vấn đề là cạnh tranh đáng ngạc nhiên.

Clojure, 115 byte

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

Xây dựng một regex từ mỗi cặp chữ cái và xem liệu đầu vào khớp với một cặp. Rất nhiều cách thanh lịch hơn để làm tất cả những phần này, nhưng chúng đều dài dòng hơn. Đó là cuộc sống với môn đánh gôn Clojure.

Perl 5, 68 + 1 = 69 byte

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

Chạy với -n .

Giải trình:

# 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 byte

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

Chạy:

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^$là một tổ hợp lấy một đối tượng regex và trả về một hàm khớp với biểu thức chính đó theo cách neo. (Chính nó, một đối tượng regex là đối tượng có thể gọi hàm, lấy một chuỗi và tự tìm kiếm thông qua nó.)

Python 3 , 66 byte

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

Hãy thử trực tuyến!

TXR : 78 74 byte

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

Chạy, từ dấu nhắc hệ thống. Số nhắc nhở là trạng thái chấm dứt: 0 = thành công, 1 = thất bại:

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:$

Giải trình:

• @{x 2}: khớp hai ký tự, liên kết với x biến.
• @(rep :gap 0)@x@(end): trận đấu lặp lại không có khoảng trống bị bỏ qua: không hoặc nhiều lần xuất hiện của x đã khớp trước đó.
• @y: phần còn lại của dòng khớp, bắt vào y.
• @(bind(x y)(foo bar)): liên kết xvới foo, y với bar. Vì xvà yđã bị ràng buộc, họ phải khớp foovà bar, nếu không thì có một thất bại.
• foolà #"nu un mw wm bq qb", một danh sách từ theo nghĩa đen, đường cú pháp cho danh sách Lisp("nu" "un" ... "qb") . Một bindtrận đấu giữa một biến và một danh sách các phương tiện mà các biến phải phù hợp với một phần tử.
• barlà @[x 0..1]: chuỗi con một ký tự xtừ đầu. Các bindtrận đấu giữa yvà các lực lượng này lá thư cuối cùng của dòng để phù hợp với người đầu tiên.

C ++, 268 byte

#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 byte

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

Trả về 1 hoặc0 .

Giải trình

Tất cả các chuỗi cartwheel sẽ có một hoặc nhiều bq , wm hoặc un . Chúng tôi kiểm tra điều đó với:

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

Nếu bạn thay thế tất cả các trường hợp của hai chữ cái đầu tiên của chuỗi cartwheel bằng không có gì, bạn sẽ để lại chữ cái đầu tiên của chuỗi. Chúng tôi kiểm tra điều đó với:

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