¿Es esta cuerda una letra que hace una voltereta?

35

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 , ¡el código más corto (en cada idioma) gana!

MD XF
fuente
29
Creo que se da bvuelta q, ¿no? dy ptambién son compañeros de volteretas. La clave es que giran, no giran.
Engineer Toast
Otra sugerencia de prueba:uwuwuwuwuwu
Kritixi Lithos
19
¿Por qué bqbpero no pdp?
aschepler
@aschepler me equivoqué.
MD XF
2
Como dpd, pdp y eso no funciona, creo que debería tenerlos en los casos de prueba con una respuesta falsa.
Trlyly

Respuestas:

2

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)
Jonathan Allan
fuente
13

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
Kritixi Lithos
fuente
Aquí viene el sedasistente ...
MD XF
@MDXF Estoy lejos de ser un mago, todavía soy un principiante :)
Kritixi Lithos
Todo me sedparece magia. : P
MD XF
1
Solo tiene que verificar la contención de la mitad de los pares de letras, por ejemplo, ambos unuy nuncontener, nuy la segunda línea garantiza que el resto de las letras coincidan con esos dos.
Neil
8

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

Arnauld
fuente
¿Alguna razón para irse en &&lugar de &?
@ThePirateBay Bueno, la única razón es la consistencia del valor falso devuelto, aunque en realidad no parece ser un requisito para este desafío. (Usar &produciría cualquiera falseo 0.)
Arnauld
@Arnauld Puede eliminar el segundo &; En algún momento especifiqué (en el chat) que se permiten valores falsos inconsistentes.
MD XF
5

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!

totalmente humano
fuente
2
suspira cuando me pasas de nuevo al representante
MD XF
No me siento bien con esto, ya que estás a punto de alcanzar mi recuento de bytes nuevamente, pero -2 bytes .
Sr. Xcoder
Por cierto, su solución no es válida, al igual que la mía al principio. Falla por nunununu.
Sr. Xcoder
Se corrigió a costa de muchos bytes. ; -;
Totalmente humano el
5

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!

Harrichael
fuente
Buena respuesta, bienvenido al sitio! Algunos consejos: puede hacer "nu un nm mn bp pb".split()para guardar 4 bytes, y puede eliminar algunos espacios en blanco. 75 bytes:lambda s:any(s==c[-1]+c*max(len(s)/2,1)for c in"nu un nm mn bp pb".split())
DJMcMayhem
Puede guardar 1 byte haciendo en s[0]lugar de c[-1].
DJMcMayhem
La respuesta de 61 bytes devuelve True para unmnuy unmwnu. Realmente devuelve falsos positivos cuando (s==s[::-1])+len(set(s))es 4, lo cual es fácil de forzar. Incluso solo 4 caracteres diferentes hacen que regrese True.
Arnold Palmer
Los 59 bytes se rompen con entradas de un solo carácter. Perdón por elegir este, me gusta Python :)
Arnold Palmer
¿No son excepciones falsey? Ese descanso es intencional
Harrichael
5

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.

Sr. Xcoder
fuente
No falla ningún caso de prueba, buen trabajo +1
MD XF
@MDXF ¡Oh, gracias! Estoy muy aliviado rn ...> _ <
Sr. Xcoder
1
uwuwuwuwuwuresultados en verdad
Kritixi Lithos
1
Inválido: nunuuunun
Harrichael
1
nuuun -> True. Esto no está bien.
recursivo el
5

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

MT0
fuente
Realmente amo la lógica aquí! Nunca hubiera pensado en agregar un personaje al final y probarlo. Código agradable y limpio, incluso cuando se juega golf.
Trlyly
4

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))))
Carcigenicate
fuente
4

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
nimi
fuente
4

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.

xnor
fuente
|u|se interpreta como una voltereta.
Harrichael
@Harrichael pongo DELcaracteres para que quede claro.
xnor
Sin embargo, los caracteres DEL aún pueden ser caracteres de entrada. Me gusta su solución, sino que debe pedir prestado un truco de mi respuesta:s[:3]in'bqbqnunuwmwm'
Harrichael
4

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!

Okx
fuente
La versión más nueva genera veracidad para nunwmwnun(cuando debería ser falsa), por lo que tenía la \1*respuesta en mi sed.
Kritixi Lithos
@Cowsquack Ah, ya veo.
Okx
La primera línea puede ser G`nu|mw|bpporque todas las cadenas verdaderas contienen uno de esos pares de letras y la segunda línea asegurará que todo el resto de la cadena contenga esas letras también ..
Neil
@Neil Eso falla el caso de pruebaununununu
Okx
La sugerencia de @Okx Neil todavía parece funcionar para ese caso de prueba
Kritixi Lithos
3

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 (..)+.
Zgarb
fuente
2

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.

Sr. Xcoder
fuente
2

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]
Hiperneutrino
fuente
Jelly ... ¿más larga que Pyth?
Sr. Xcoder
@ Mr.Xcoder shhhh estoy trabajando en ello ... xD
HyperNeutrino
Ja, bueno, ahora estoy atado contigo xD
HyperNeutrino
2

Japt , 47 bytes

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

Pruébalo en línea!

Oliver
fuente
¿Se puede comprimir la cadena para guardar bytes?
Shaggy
nwnwn es cierto cuando debería ser falso
Harrichael
@Harrichael ¡Gracias, arreglado!
Oliver
1

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!

nocturama
fuente
1

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.

Xcali
fuente
Derrótame por un sólido 18 bytes. ¡Buena respuesta!
Silvio Mayolo
No tantos ahora. El original volvía verdadero para cualquier cadena del mismo carácter.
Xcali
1

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.

Titus
fuente
1

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 ^...$.

Kevin Cruijssen
fuente
1

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
Luis Mendo
fuente
0

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.

Lynn
fuente
0

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.

MattPutnam
fuente
0

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).
}
Silvio Mayolo
fuente
0

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

Kaz
fuente
0

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.
Kaz
fuente
0

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;}
HatsuPointerKun
fuente
Ahorre 10 bytes utilizando los valores ASCII para todos los caracteres en lugar de solo dos.
MD XF
@MDXF n= 110, u= 117, m= 109, w= 119, q= 113. Por lo tanto, usar valores ASCII o no no importa para ningún carácter superior a c(99)
HatsuPointerKun
0

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]

Rick Hitchcock
fuente