Die Inspiration für die Challenge war die, die ich irgendwo gesehen habe:

Das Wort "Nonne" ist nur der Buchstabe n , der ein Rad dreht

Ihre Herausforderung besteht darin, eine Schnur zu nehmen und festzustellen, ob es sich um den ersten Buchstaben handelt, der ein Rad dreht.

Regeln

Eine Zeichenfolge ist ein Buchstabe, der ein Rad dreht, wenn:

• Der erste Buchstabe ist der gleiche wie der letzte Buchstabe. (Der Brief kann nicht auf dem Kopf landen.)
• Die Zeichenfolge wechselt zwischen Wagenradbuchstaben für jedes Zeichen.

Die Wagenradbuchstaben sind nund u, mund w, bund q. Beachten Sie, dass nund wzusammen keine Wagenradbuchstaben sind und auch nicht wund b.

• Sie nehmen eine Zeichenfolge mit einer unserer Standardeingabemethoden.
• Sie geben einen Wahrheitswert aus, wenn die Zeichenfolge ein Wagenradbuchstabe ist, und einen falschen Wert, wenn dies nicht der Fall ist. Die Ausgabe kann mit beliebigen Standardausgabemethoden erfolgen.

Zusätzliche Regeln:

• Es dürfen nur Kleinbuchstaben n/ u/ m/ w/ b/ verwendet qwerden.
• Sie können davon ausgehen, dass die Eingabe niemals leer ist.
• Eine einstellige Zeichenfolge ist kein gültiges Rad.

Testfälle

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

Gewinner

Wie beim Code-Golf gewinnt der kürzeste Code (in jeder Sprache)!

Jelly , 23 Bytes

_{Das hat mehr Arbeit gekostet, als man denkt!}

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

Ein monadischer Link, der eine Liste von Charakteren 1aufnimmt und (wahrheitsgemäß) oder 0(falsch) zurückgibt.

Probieren Sie es online! oder sehen Sie sich eine Testsuite an .

Wie?

Sucht den Index jedes Zeichens der Eingabe in der 1-indizierten Zeichenliste nmbuwq. Diese Zeichenfolge ist so angeordnet, dass die Indizes von Paaren drei voneinander entfernt sind, da die inkrementelle Differenz der Indizes für gültige Wagenräder Wiederholungen von einem von [-3,3]oder sind [3,-3].

Wenn ein Element nicht durch den "Index von" Atom in einer Liste gefunden wird, igibt es zurück 0, die nicht gefundene Zeichen mit koppeln würde b, Eingabe wie bxbxbwahr. Daher werden 0s 10vor der Gültigkeitsprüfung durch einen Wert ersetzt, der mehr als drei von allen anderen Werten entfernt ist.

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

12 Byte dank @Neil durch Verkürzung der ersten Zeile eingespart

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

Probieren Sie es online!

Löscht die Eingabe, wenn sie falsch ist, andernfalls wird die Eingabe nicht bearbeitet.

Erläuterung

Mit dem -rFlag müssen wir \(und nicht \)zum Erfassen von Gruppen verwenden und dies spart Bytes.

/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

1 Byte mit zwei falschen Werten gespeichert, wie von ThePirateBay und MD XF vorgeschlagen.

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

Testfälle

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 Bytes

-2 Bytes dank 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'])

Probieren Sie es online!

Python 2 , 63 Bytes

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

Probieren Sie es online!

Python 3 , 71 Bytes

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

Probieren Sie es online!

-1 dank @HyperNeutrino und -13 dank @ovs

Wenn sich herausstellt, dass der obige Testfall fehlgeschlagen ist, gibt es eine Alternative:

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

Probieren Sie es online!

Erläuterung

• ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) - Ermittelt die Zeichen bei ungeraden Indizes und die Zeichen bei geraden Indizes, de-dupliziert sie und sortiert die durch ihre Vereinigung gebildete Liste.

• in'nu,mw,bq' - Überprüft, ob es sich um gültige Cart-Letter-Kombinationen handelt.

• n[0]==n[-1] - Überprüft, ob das erste Zeichen mit dem letzten übereinstimmt.

JavaScript (ES6), 40 Byte

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

Überprüft, ob die mit dem zweiten Zeichen der Eingabezeichenfolge verknüpfte Eingabezeichenfolge eine sich wiederholende Zeichenfolge desselben Wagenradzeichenpaars ist.

Tests:

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

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

Das war täuschend schwierig! Ich musste es in 3 Unterprobleme aufteilen:

• Ist der erste Buchstabe der gleiche wie der letzte?
• Wiederholen sich die Buchstaben?
• Sind alle Buchstaben Teil einer der gültigen Mengen?

Ich habe auf keinen Fall gewonnen, aber das war eine gute Morgenübung! Vollständige Erklärung unten:

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

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

Probieren Sie es online!

Wie es funktioniert:

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 Bytes

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

Probieren Sie es online!

Die Leerzeichen in der Zeichenfolge sind DELZeichen.

Retina , 24 Bytes

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

Gibt 1 für wahr, 0 für falsch aus.

Antwort von Port of Cows.

Probieren Sie es online!

Schmutz , 28 Bytes

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

Probieren Sie es online! Drucke 1für truthy Eingänge und 0für falsy diejenigen.

Erläuterung

Die Grime-Syntax ähnelt regulären Ausdrücken, und ein Grime-Programm gibt ein Muster an, das mit einem Rechteck von Zeichen übereinstimmen kann oder nicht.

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.

Einige Features von Grime, die dazu beigetragen haben, dies zu verkürzen:

• Normalerweise muss ein Zeichenliteral mit einem Backslash maskiert werden, dies ""ändert sich jedoch: Syntaxelemente werden maskiert, Literale jedoch nicht. Ohne die Anführungszeichen wäre der Teil, der die Zeichenpaare auflistet (\n\u|\b\p|\m\w)oT.
• Unäre Operatoren, die einem binären Operator folgen (hier -), wirken sich auf das Ergebnis aus: ..-#!"…"oTist äquivalent zu (..-"…"oT)#!.
• Je vniedriger die Priorität der darauf folgenden Syntaxelemente. Ein Einzelner &hat eine höhere Priorität als -, aber v&eine niedrigere. Ebenso ..+wird analysiert als .(.+), ist aber ..v+äquivalent zu (..)+.

Python 2 , 69 Bytes

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

Probieren Sie es online!

Pyth , 27 Bytes

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

Test Suite.

Ausgaben 1für Wahr und Falseoder 0für Falsch, wie das OP im Chat erlaubt.

Gelee , 27 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

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]

Probieren Sie es online!

Japt , 47 Bytes

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

Probieren Sie es online!

Python 3 , 88 Bytes

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: Eine gerade Zeichenfolge darf nicht mit dem ersten Zeichen enden

x[:2] in: Überprüfen Sie, ob eines der 6 gültigen Anfangspaare vorhanden ist

len(set()): Länge der Zeichensätze bei 0,2,4 ... und 1,3,5 ... ermitteln

Gibt zurück, Truewenn die Liste der Bewertungen gleich [1,1,1,1] ist, sonst False.

Probieren Sie es online!

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

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

Probieren Sie es online!

Druckt die "verkehrte" Version des ersten Zeichens für wahr, nichts für falsch.

PHP, 59 + 1 Bytes

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

Als Rohr mit laufen lassen -F.

Teilweise Regex-Lösung, 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));

Leere Ausgabe für falsch. Als Rohr mit laufen lassen -nR.

Java 8, 57 Bytes

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

Probieren Sie es hier aus.

Einfache Regex für alle sechs Fälle. Beachten Sie, dass Java String#matchesautomatisch mit der gesamten Zeichenfolge übereinstimmt, sodass dies nicht erforderlich ist ^...$.

MATL , 25 Bytes

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

Die Ausgabe ist ein nicht leerer numerischer Spaltenvektor, der wahr ist, wenn alle seine Einträge ungleich Null sind, und ansonsten falsch ist . Probieren Sie es online!

Um alle Testfälle zu überprüfen , ifwird in der Fußzeile eine Verzweigung hinzugefügt, die einen Wahrheitswert durch die Zeichenfolge 'truthy'oder einen falschen Wert durch die Zeichenfolge ersetzt'falsy' , und anschließend die Zeichenfolge angezeigt.

Erläuterung

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

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

Probieren Sie es online! Dieses Problem ist überraschend konkurrenzfähig.

Clojure, 115 Bytes

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

Erstellen Sie aus jedem Buchstabenpaar einen regulären Ausdruck und prüfen Sie, ob die Eingabe mit einer übereinstimmt. Viele elegantere Möglichkeiten, all diese Teile zu erledigen, aber sie sind alle ausführlicher. So ist das Leben mit Clojure Golf.

Perl 5, 68 + 1 = 69 Bytes

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

Laufen Sie mit -n.

Erläuterung:

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

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

Lauf:

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^$ist ein Kombinator, der ein Regex-Objekt nimmt und eine Funktion zurückgibt, die verankert mit diesem Regex übereinstimmt. (Ein reguläres Objekt ist ein funktionsaufrufbares Objekt, das eine Zeichenfolge aufnimmt und nach sich selbst sucht.)

Python 3 , 66 Bytes

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

Probieren Sie es online!

TXR : 78 74 Bytes

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

Führen Sie von der Systemaufforderung aus. Die Nummer in der Eingabeaufforderung ist der Beendigungsstatus: 0 = Erfolg, 1 = Fehler:

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

Erläuterung:

• @{x 2}: stimmen mit zwei Zeichen überein, binde an xVariable.
• @(rep :gap 0)@x@(end): wiederholte Übereinstimmung ohne übersprungene Lücken: null oder mehr Vorkommen des xzuvor übereinstimmenden Digraphen.
• @y: Rest der Zeile stimmt überein, erfasst in y.
• @(bind(x y)(foo bar)): binden xan foo, y an bar. Da xund ysind sie bereits gebunden, müssen sie übereinstimmen foound barsonst liegt ein Fehler vor.
• fooist #"nu un mw wm bq qb"ein wortlistenliteraler syntaktischer Zucker für die Lisp-Liste ("nu" "un" ... "qb"). Eine bindÜbereinstimmung zwischen einer Variablen und einer Liste bedeutet, dass die Variable mit einem Element übereinstimmen muss.
• barist @[x 0..1]: die Ein-Zeichen-Teilzeichenfolge von xAnfang an. Die bindÜbereinstimmung zwischen yund bewirkt, dass der letzte Buchstabe der Zeile mit dem ersten übereinstimmt.

C ++, 268 Bytes

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

Rückgabe 1oder 0.

Erläuterung

Alle Wagenradsaiten haben einen oder mehrere Werte von bq , wm oder un . Wir testen das mit:

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

Wenn Sie alle Instanzen der ersten beiden Buchstaben einer Wagenradzeichenfolge durch nichts ersetzen, bleibt der erste Buchstabe der Zeichenfolge übrig. Wir testen das mit:

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