L'inspiration du défi était ce que j'ai vu quelque part:

Le mot "nonne" est juste la lettre n faisant une roue

Votre défi est de prendre une ficelle et de déterminer s’il s’agit de la première lettre faisant une roue.

Règles

Une ficelle est une lettre faisant la roue si:

• La première lettre est la même que la dernière lettre. (La lettre ne peut pas atterrir sur sa tête.)
• La chaîne alterne des lettres à la molette, chaque caractère.

Les lettres en forme de roue sont nand u, mand w, band q. Notez que net wensemble sont pas renversant sur les lettres, ni sont wet b.

• Vous allez prendre une chaîne en utilisant l’une de nos méthodes d’entrée standard.
• Vous produirez une valeur de vérité si la chaîne est une lettre, et une valeur de fausseté si ce n'est pas le cas. La sortie peut être effectuée en utilisant n'importe quelle méthode de sortie standard.

Règles supplémentaires:

• Seules les lettres minuscules n/ u/ m/ w/ b/ qdoivent être manipulées.
• Vous pouvez supposer que l'entrée n'est jamais vide.
• Une chaîne d'un caractère n'est pas une roue valide.

Cas de test

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

Gagnant

Comme pour le code-golf , le code le plus court (dans chaque langue) gagne!

Gelée , 23 octets

_{Cela a pris plus de travail qu'on pourrait le penser!}

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

Un lien monadique prenant une liste de caractères et retournant 1(vérité) ou 0(falsey).

Essayez-le en ligne! ou voir une suite de tests .

Comment?

Recherche l'index de chaque caractère de l'entrée dans la liste de caractères indexée 1 nmbuwq. Cette chaîne est disposée de telle sorte que les index des paires sont trois à part, en tant que tel la différence incrémentale des index pour la roue valide sera répétitions de l' une [-3,3]ou [3,-3].

Quand un élément n'est pas trouvé dans une liste par "l'index" de l'atome i, il retourne 0, ce qui ferait correspondre les caractères non fondus avec b, en faisant une entrée comme une bxbxbvérité. Ainsi, 0s est remplacé par 10une valeur distante de plus de trois de toute autre valeur avant de vérifier sa validité.

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

Économisé 12 octets grâce à @Neil en raccourcissant la première ligne

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

Essayez-le en ligne!

Supprime l'entrée si falsey, sinon ne fait rien à l'entrée.

Explication

Avec l' -rindicateur, nous n'avons pas besoin d'utiliser \(et \)de capturer des groupes, cela économise des octets.

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

Sauvé 1 octet en utilisant deux valeurs de fausseté, comme suggéré par ThePirateBay et MD XF.

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

Cas de test

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 octets

-2 octets merci à M. 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'])

Essayez-le en ligne!

Python 2 , 63 octets

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

Essayez-le en ligne!

Python 3 , 71 octets

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

Essayez-le en ligne!

-1 grâce à @HyperNeutrino et -13 grâce à @ovs

S'il s'avère que ce qui précède a échoué pour n'importe quel cas de test, il existe une alternative:

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

Essayez-le en ligne!

Explication

• ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) - Obtient les caractères aux index impairs et les caractères aux index pairs, les dédoublonne et trie la liste formée par leur union.

• in'nu,mw,bq' - Vérifie s’il s’agit de combinaisons valides de lettres panier.

• n[0]==n[-1] - Vérifie si le premier caractère est identique au dernier.

JavaScript (ES6), 40 octets

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

Vérifie si la chaîne d'entrée concaténée avec le deuxième caractère de la chaîne d'entrée est une chaîne répétitive de la même paire de caractères de roue à la base.

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 octets

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

C'était trompeusement difficile! J'ai fini par devoir le décomposer en 3 problèmes secondaires:

• La première lettre est-elle la même que la dernière?
• Est-ce que les lettres se répètent?
• Toutes les lettres font-elles partie de l’un des jeux valides?

Je n’ai certes pas gagné, mais c’était un bon exercice du matin! Explication complète ci-dessous:

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

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

Essayez-le en ligne!

Comment ça marche:

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 octets

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

Essayez-le en ligne!

Les espaces dans la chaîne sont des DELcaractères.

Retina , 24 octets

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

Sorties 1 pour la vérité, 0 pour la fausseté.

La réponse du charlatan du port des vaches.

Essayez-le en ligne!

Grime , 28 octets

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

Essayez-le en ligne! Imprime 1pour les entrées de vérité et 0pour les faux.

Explication

La syntaxe Grime ressemble aux expressions régulières et un programme Grime spécifie un modèle qui peut correspondre ou non à un rectangle de caractères.

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.

Quelques fonctionnalités de Grime qui ont permis de raccourcir ceci:

• Normalement, un littéral de caractère doit être échappé avec une barre oblique inverse, mais ""change ceci: les éléments de syntaxe sont échappés, mais pas les littéraux. Sans les guillemets, la partie qui énumère les paires de caractères serait (\n\u|\b\p|\m\w)oT.
• Les opérateurs unaires qui suivent un opérateur binaire (ici -) agissent sur son résultat: ..-#!"…"oTest équivalent à (..-"…"oT)#!.
• Les vs abaissent la priorité des éléments de syntaxe qui les suivent. Un solitaire &a plus de priorité que -, mais v&a moins. De même, ..+est analysé comme .(.+), mais ..v+équivaut à (..)+.

Python 2 , 69 octets

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

Essayez-le en ligne!

Pyth , 27 octets

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

Suite de tests.

Sorties 1de vérité et / Falseou 0de fausseté, comme l'OP le permettait dans le chat.

Gelée , 27 octets

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

Essayez-le en ligne!

Comment ça marche

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

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]

Essayez-le en ligne!

Japt , 47 octets

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

Essayez-le en ligne!

Python 3 , 88 octets

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: une chaîne de longueur égale ne peut pas se terminer sur le premier caractère

x[:2] in: recherchez l’une des 6 paires de départ valides

len(set()): obtenez la longueur des jeux de caractères à 0,2,4 ... et 1,3,5 ...

Retourne Truesi la liste des évaluations est égale à [1,1,1,1], sinon False.

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Imprime la version "à l'envers" du premier caractère pour vrai, rien pour faux.

PHP, 59 + 1 octets

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

Courez comme un tuyau avec -F.

solution partiellement regex, 101 + 1 octets:

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

Sortie vide pour fausseté. Courez comme un tuyau avec -nR.

Java 8, 57 octets

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

Essayez ici.

Regex simple pour correspondre à tous les six cas. Notez que Java String#matchescorrespond automatiquement à la chaîne entière, il n'y a donc pas besoin de ^...$.

MATL , 25 octets

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

La sortie est un vecteur de colonne numérique non vide, ce qui est vrai si toutes ses entrées sont non nulles et faux si ce n'est pas le cas. Essayez-le en ligne!

Pour vérifier tous les cas de test , une ifbranche est ajoutée dans le pied de page. Elle remplace toute valeur de vérité par la chaîne 'truthy'ou toute valeur de faux par la chaîne 'falsy', puis affiche la chaîne.

Explication

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

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

Essayez-le en ligne! Cette prise en compte du problème est étonnamment compétitive.

Clojure, 115 octets

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

Construisez une expression régulière à partir de chaque paire de lettres et voyez si l'entrée correspond à une. Beaucoup de façons plus élégantes de faire toutes ces parties, mais elles sont toutes plus verbeuses. Telle est la vie avec Clojure golfing.

Perl 5, 68 + 1 = 69 octets

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

Courez avec -n.

Explication:

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

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

Courir:

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^$est un combinateur qui prend un objet regex et renvoie une fonction qui correspond à cette regex de manière ancrée. (En lui-même, un objet regex est un objet appelable par une fonction qui prend une chaîne et se cherche à travers elle.)

Python 3 , 66 octets

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

Essayez-le en ligne!

TXR : 78 74 octets

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

Exécuter, à partir de l'invite du système. Le nombre dans l'invite correspond au statut de fin: 0 = succès, 1 = échec:

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

Explication:

• @{x 2}: correspond à deux caractères, lie à la xvariable.
• @(rep :gap 0)@x@(end): correspondance répétée sans lacunes ignorées: aucune ou plusieurs occurrences de x , le digraphe précédemment apparié.
• @y: reste de la ligne appariée, capturée dans y.
• @(bind(x y)(foo bar)): lier xà foo, y à bar. Depuis xet ysont déjà liés, ils doivent correspondre fooet barsinon il y a un échec.
• foois #"nu un mw wm bq qb", une liste de mots littérale, un sucre syntaxique pour la liste Lisp ("nu" "un" ... "qb"). Une bindcorrespondance entre une variable et une liste signifie que la variable doit correspondre à un élément.
• baris @[x 0..1]: la sous-chaîne d'un caractère xdepuis son début. La bindcorrespondance entre yet ceci force la dernière lettre de la ligne à correspondre à la première.

C ++, 268 octets

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

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

Retours 1ou 0.

Explication

Toutes les chaînes de la roue auront un ou plusieurs des éléments suivants: bq , wm ou un . Nous testons pour cela avec:

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

Si vous remplacez toutes les occurrences des deux premières lettres d'une chaîne de roue par rien, vous vous retrouvez avec la première lettre de la chaîne. Nous testons pour cela avec:

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