La inspiración del desafío fue esta que vi en alguna parte:

La palabra "monja" es solo la letra n haciendo una voltereta

Su desafío es tomar una cuerda y determinar si es la primera letra que hace una voltereta.

Reglas

Una cadena es una letra que hace una voltereta si:

• La primera letra es igual a la última letra. (La carta no puede aterrizar sobre su cabeza).
• La cadena alterna entre letras de carretas cada carácter.

Las letras del carro son ny u, my w, by q. Tenga en cuenta que ny wjuntos no son letras que giran en el carro, y tampoco lo son wy b.

• Tomarás una cadena usando cualquiera de nuestros métodos de entrada estándar.
• Producirá un valor verdadero si la cadena es una letra de volteo y un valor falso si no lo es. La salida se puede hacer usando cualquier método de salida estándar.

Reglas adicionales:

• Solo se deben manejar las letras minúsculas de la carretilla n/ u/ m/ w/ b/ q.
• Puede suponer que la entrada nunca está vacía.
• Una cadena de un carácter no es una voltereta válida.

Casos de prueba

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

Ganador

Al igual que con el código de golf , ¡el código más corto (en cada idioma) gana!

Jalea , 23 bytes

_{¡Esto tomó más trabajo de lo que uno podría pensar!}

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

Un enlace monádico que toma una lista de personajes y regresa 1(verdad) o 0(falsey).

Pruébalo en línea! o ver un conjunto de pruebas .

¿Cómo?

Encuentra el índice de cada carácter de la entrada en la lista de caracteres indexados en 1 nmbuwq. Esta cadena está dispuesta de tal manera que los índices de pares están separados por tres, por lo que la diferencia incremental de los índices para volteretas válidas serán repeticiones de uno de [-3,3]o [3,-3].

Cuando un elemento no se encuentra en una lista por el átomo del "índice de" i, devuelve 0, lo que emparejaría caracteres no encontrados b, haciendo que la entrada sea bxbxbverdadera. Por lo tanto, los 0s se reemplazan por 10un valor a más de tres de cualquier otro valor antes de verificar la validez.

“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

Ahorró 12 bytes gracias a @Neil al acortar la primera línea

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

Pruébalo en línea!

Elimina la entrada si falsey, de lo contrario no hace nada a la entrada.

Explicación

Con la -rbandera, no necesitamos usar \(y \)para capturar grupos y esto ahorra 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 bytes

Se guardó 1 byte utilizando dos valores falsos, como lo sugieren ThePirateBay y MD XF.

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

Casos de prueba

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 gracias al Sr. 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'])

Pruébalo en línea!

Python 2 , 63 bytes

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

Pruébalo en línea!

Python 3 , 71 bytes

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

Pruébalo en línea!

-1 gracias a @HyperNeutrino y -13 gracias a @ovs

Si se encuentra que lo anterior falla para cualquier caso de prueba, hay una alternativa:

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

Pruébalo en línea!

Explicación

• ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) - Obtiene los caracteres en índices impares y los caracteres en índices pares, los duplica y ordena la lista formada por su unión.

• in'nu,mw,bq' - Comprueba si son combinaciones válidas de carrito-carta.

• n[0]==n[-1] - Comprueba si el primer carácter es el mismo que el último.

JavaScript (ES6), 40 bytes

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

Comprueba si la cadena de entrada concatenada con el segundo carácter de la cadena de entrada es una cadena repetitiva del mismo par de caracteres de volteretas.

Pruebas:

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

¡Esto fue engañosamente difícil! Terminé teniendo que dividirlo en 3 subproblemas:

• ¿La primera letra es igual a la última?
• ¿Se repiten las letras?
• ¿Todas las letras son parte de uno de los conjuntos válidos?

Ciertamente no gané, ¡pero este fue un buen ejercicio de la mañana! Explicación completa a continuación:

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

Pruébalo en línea!

Cómo funciona:

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'

Pruébalo en línea!

Los espacios en la cadena son DELcaracteres.

Retina , 24 bytes

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

Salidas 1 para verdad, 0 para falsedad.

La respuesta del curandero del puerto de vacas.

Pruébalo en línea!

Grime , 28 bytes

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

Pruébalo en línea! Imprime 1para entradas verdaderas y 0falsas.

Explicación

La sintaxis de Grime se asemeja a las expresiones regulares, y un programa de Grime especifica un patrón que puede coincidir o no con un rectángulo de caracteres.

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.

Algunas características de Grime que ayudaron a acortar esto:

• Normalmente, se debe escapar un carácter literal con una barra diagonal inversa, pero ""esto cambia: los elementos de sintaxis se escapan pero los literales no. Sin las comillas, la parte que enumera los pares de caracteres sería(\n\u|\b\p|\m\w)oT .
• Los operadores unarios que siguen a un operador binario (aquí -) actúan sobre su resultado: ..-#!"…"oTes equivalente a (..-"…"oT)#!.
• Los vs reducen la precedencia de los elementos de sintaxis que los siguen. Un solitario &tiene mayor prioridad que -, pero v&tiene menor. Del mismo modo, ..+se analiza como .(.+), pero ..v+es equivalente a (..)+.

Python 2 , 69 bytes

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

Pruébalo en línea!

Pyth , 27 bytes

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

Banco de pruebas.

Salidas 1para Truthy y Falseo 0para Falsy, como el PO permitido en el chat.

Jalea , 27 bytes

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

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea!

Japt , 47 bytes

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

Pruébalo en línea!

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: una cadena de longitud par no puede terminar en el primer carácter

x[:2] in: verifique cualquiera de los 6 pares iniciales válidos

len(set()): obtenga la longitud de los conjuntos de caracteres en 0,2,4 ... y 1,3,5 ...

Devuelve Truesi la lista de evaluaciones es igual a [1,1,1,1], de lo contrario False.

Pruébalo en línea!

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

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

Pruébalo en línea!

Imprime la versión "al revés" del primer personaje para verdadero, nada para falso.

PHP, 59 + 1 bytes

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

Ejecutar como tubería con -F.

solución parcialmente regex, 101 + 1 bytes:

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

Salida vacía para falsedad. Ejecutar como tubería con -nR.

Java 8, 57 bytes

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

Pruébalo aquí

Regex simple para combinar los seis casos. Tenga en cuenta que Java String#matchescoincide automáticamente con toda la cadena, por lo que no es necesario ^...$.

MATL , 25 bytes

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

La salida es un vector de columna numérica no vacío, que es verdadero si todas sus entradas son distintas de cero, y falso de lo contrario. Pruébalo en línea!

Para verificar todos los casos de prueba , ifse agrega una rama en el pie de página que reemplaza cualquier valor verdadero por la cadena 'truthy', o cualquier valor falso por la cadena'falsy' , y luego muestra la cadena.

Explicación

'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

Pruébalo en línea! Esta toma del problema es sorprendentemente competitiva.

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

Construya una expresión regular de cada par de letras y vea si la entrada coincide con una. Muchas formas más elegantes de hacer todas estas partes, pero todas son más detalladas. Así es la vida con el golf Clojure.

Perl 5, 68 + 1 = 69 bytes

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

Corre con -n.

Explicació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 bytes

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

Correr:

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^$es un combinador que toma un objeto regex y devuelve una función que coincide con esa expresión regular de forma anclada. (Por sí mismo, un objeto regex es un objeto invocable por funciones que toma una cadena y la busca a través de ella).

Python 3 , 66 bytes

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

Pruébalo en línea!

TXR : 78 74 bytes

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

Ejecutar, desde el indicador del sistema. El número en la solicitud es el estado de terminación: 0 = éxito, 1 = falla:

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

Explicación:

• @{x 2}: coincide con dos caracteres, se une a la xvariable.
• @(rep :gap 0)@x@(end): coincidencia repetida sin espacios omitidos: cero o más ocurrencias del xdígrafo previamente coincidente.
• @y: resto de línea coincidente, capturado en y.
• @(bind(x y)(foo bar)): enlazar xa foo, y a bar. Como xya yestán obligados, tienen que coincidir fooy bar, de lo contrario, hay un fallo.
• fooes #"nu un mw wm bq qb", una lista de palabras literal, azúcar sintáctica para la lista Lisp ("nu" "un" ... "qb"). Una bindcoincidencia entre una variable y una lista significa que la variable debe coincidir con un elemento.
• bares @[x 0..1]: la subcadena de un carácter de xdesde el principio. La bindcoincidencia entre yy esto obliga a que la última letra de la línea coincida con la primera.

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 bytes

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

Devoluciones 1o 0.

Explicación

Todas las cadenas de volteretas tendrán uno o más de bq , wm o un . Probamos eso con:

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

Si reemplaza todas las instancias de las dos primeras letras de una cadena de volteretas con nada, le queda la primera letra de la cadena. Probamos eso con:

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