挑战灵感是我在某处看到的：

单词“尼姑”只是字母ñ做一个侧手翻

您面临的挑战是取一个字符串并确定它是否是执行车轮的第一个字母。

规则

字符串是满足以下条件的字母：

• 第一个字母与最后一个字母相同。（这封信不能落在头上。）
• 该字符串在每个字符之间交替显示。

翻车的字母是n和u，m和w，b和q。需要注意的是n和w一起不 cartwheeling字母，也不是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

优胜者

与代码高尔夫球一样，最短的代码（每种语言）胜出！

果冻，23 字节

_{这花了比想象的更多的工作！}

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

1单字链接，其中包含字符列表，并返回（真）或0（假）。

在线尝试！或查看测试套件。

怎么样？

在1索引字符列表中查找输入的每个字符的索引nmbuwq。该字符串的排列方式是使成对的索引相隔三个，因此有效车轮的索引增量将是[-3,3]或的重复[3,-3]。

当原子“ index of”未在列表中找到某项时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字节

@Neil通过缩短第一行节省了12个字节

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

在线尝试！

如果为false，则删除输入，否则对输入不执行任何操作。

说明

使用该-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字节

根据ThePirateBay和MD XF的建议，使用两个伪造的值保存了1个字节。

([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个字节，感谢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])

检查与输入字符串的第二个字符连接的输入字符串是否是同一对车轮字符的重复字符串。

测试：

[
  "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表示虚假。

牛港口码头的答案。

在线尝试！

污垢，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假。

果冻，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，否则为false。

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。

Java 8，57字节

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

在这里尝试。

简单的正则表达式可以匹配所有六个案例。请注意，Java会String#matches自动匹配整个String，因此不需要^...$。

MATL，25个字节

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

的输出中是一个非空的数值列向量，这是truthy如果其所有条目是非零，和falsy否则。在线尝试！

为了验证所有测试用例，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

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

从每个字母对中构建一个正则表达式，然后查看输入是否匹配一个。许多更优雅的方式可以完成所有这些部分，但它们都比较冗长。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^$是一个组合器，它接受一个正则表达式对象，并以锚定方式返回与该正则表达式匹配的函数。（就其本身而言，正则表达式对象是可调用函数的对象，该对象接受字符串并通过字符串进行搜索。）

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"一个单词列表文字，是Lisp列表的语法糖("nu" "un" ... "qb")。甲bind变量并且该变量必须的元件匹配列表的装置之间的匹配。
• baris @[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]

返回1或0。

说明

所有车轮串都将具有bq，wm或un中的一个或多个。我们使用以下方法进行测试：

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

如果将车​​轮字符串的前两个字母的所有实例替换为空，则剩下该字符串的第一个字母。我们使用以下方法进行测试：

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