L'ispirazione della sfida è stata questa che ho visto da qualche parte:

La parola "suora" è solo la lettera n che fa una ruota dentata

La tua sfida è quella di prendere una stringa e determinare se è la prima lettera a fare una ruota a ruota.

Regole

Una stringa è una lettera che fa un cartwheel se:

• La prima lettera è la stessa dell'ultima lettera. (La lettera non può atterrare sulla sua testa.)
• La stringa si alterna tra lettere a ruota libera ogni carattere.

Le lettere rotanti sono ne u, me w, be q. Si noti che ne winsieme non sono lettere a ruota libera, e nemmeno lo sono we b.

• Prenderai una stringa usando uno dei nostri metodi di input standard.
• Verrà emesso un valore di verità se la stringa è una lettera a ruota libera e un valore di falsa se non lo è. L'output può essere eseguito utilizzando qualsiasi metodo di output standard.

Regole aggiuntive:

• Devono essere gestite solo lettere minuscole n/ u/ m/ w/ b/ minuscole q.
• Si può presumere che l'input non sia mai vuoto.
• Una stringa di un carattere non è un cartwheel valido.

Casi 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

Vincitore

Come nel code-golf , vince il codice più corto (in ogni lingua)!

Gelatina , 23 byte

_{Ciò ha richiesto più lavoro di quanto si possa pensare!}

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

Un collegamento monadico che prende un elenco di personaggi e ritorna 1(verità) o 0(falsità).

Provalo online! o vedere una suite di test .

Come?

Trova l'indice di ciascun carattere dell'input nell'elenco di caratteri 1 indicizzato nmbuwq. Questa stringa è disposta in modo tale che gli indici delle coppie siano separati da tre, pertanto la differenza incrementale degli indici per le cartwheel valide sarà la ripetizione di uno di [-3,3]o [3,-3].

Quando un elemento non viene trovato in un elenco dall'atomo "indice di" i, ritorna 0, che accoppierebbe i caratteri infondati b, rendendo l'input bxbxbveritiero. Quindi i messaggi di posta 0elettronica vengono sostituiti da 10un valore superiore a tre rispetto a qualsiasi altro valore prima di verificarne la 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 byte

Risparmiato 12 byte grazie a @Neil accorciando la prima riga

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

Provalo online!

Elimina l'input se false, altrimenti non fa nulla sull'input.

Spiegazione

Con la -rbandiera, non abbiamo bisogno di usare \(e \)per catturare gruppi e questo fa risparmiare byte.

/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

Salvato 1 byte utilizzando due valori di falsy, come suggerito da ThePirateBay e MD XF.

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

Casi 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 byte

-2 byte grazie a 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'])

Provalo online!

Python 2 , 63 byte

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

Provalo online!

Python 3 , 71 byte

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

Provalo online!

-1 grazie a @HyperNeutrino e -13 grazie a @ovs

Se si riscontra che quanto sopra fallisce per qualsiasi caso di test, esiste un'alternativa:

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

Provalo online!

Spiegazione

• ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) - Ottiene i caratteri su indici dispari e i caratteri su indici pari, li de-duplica e ordina l'elenco formato dalla loro unione.

• in'nu,mw,bq' - Verifica se si tratta di combinazioni valide carrello-lettera.

• n[0]==n[-1] - Verifica se il primo carattere è uguale all'ultimo.

JavaScript (ES6), 40 byte

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

Verifica se la stringa di input concatenata con il secondo carattere della stringa di input è una stringa ripetuta della stessa coppia di caratteri cartwheel.

test:

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

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

Questo è stato ingannevolmente difficile! Ho finito per doverlo suddividere in 3 sotto-problemi:

• La prima lettera è uguale all'ultima?
• Le lettere si ripetono?
• Tutte le lettere fanno parte di uno dei set validi?

Certamente non ho vinto, ma questo è stato un esercizio di buongiorno! Spiegazione completa di seguito:

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

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

Provalo online!

Come funziona:

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 byte

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

Provalo online!

Gli spazi nella stringa sono DELcaratteri.

Retina , 24 byte

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

Uscite 1 per verità, 0 per falsità.

La risposta del ciarlatano di Port of Cows.

Provalo online!

Grime , 28 byte

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

Provalo online! Stampe 1per input veritieri e 0per input falsi.

Spiegazione

La sintassi di Grime ricorda espressioni regolari e un programma Grime specifica un modello che può o meno corrispondere a un rettangolo di caratteri.

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.

Alcune caratteristiche di Grime che hanno contribuito a ridurre questo aspetto:

• Normalmente un carattere letterale deve essere evitato con una barra rovesciata, ma ""cambia questo: gli elementi di sintassi sono sfuggiti ma i letterali no. Senza le virgolette, la parte che enumera le coppie di caratteri sarebbe (\n\u|\b\p|\m\w)oT.
• Gli operatori unari che seguono un operatore binario (qui -) agiscono sul suo risultato: ..-#!"…"oTè equivalente a (..-"…"oT)#!.
• Le vs riducono la precedenza degli elementi di sintassi che le seguono. Un solitario &ha una precedenza più alta di -, ma v&ha una precedenza. Allo stesso modo, ..+viene analizzato come .(.+), ma ..v+equivale a (..)+.

Python 2 , 69 byte

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

Provalo online!

Pyth , 27 byte

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

Test Suite.

Output 1per verità e / Falseo 0falsità, come consentito dall'OP in chat.

Gelatina , 27 byte

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

Provalo online!

Come funziona

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

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]

Provalo online!

Japt , 47 byte

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

Provalo online!

Python 3 , 88 byte

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 stringa di lunghezza pari non può terminare con il primo carattere

x[:2] in: verifica una delle 6 coppie iniziali valide

len(set()): ottieni la lunghezza dei set di caratteri a 0,2,4 ... e 1,3,5 ...

Restituisce Truese l'elenco delle valutazioni è uguale a [1,1,1,1], altrimenti False.

Provalo online!

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

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

Provalo online!

Stampa la versione "capovolta" del primo carattere per true, niente per false.

PHP, 59 + 1 byte

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

Esegui come pipe con -F.

soluzione parzialmente regex, 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));

Uscita vuota per falsy. Esegui come pipe con -nR.

Java 8, 57 byte

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

Provalo qui.

Regex semplice per abbinare tutti e sei i casi. Nota che Java String#matchescorrisponde automaticamente all'intera stringa, quindi non è necessario ^...$.

MATL , 25 byte

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

L'uscita è un vettore di colonna numerico non vuoto, che è vero se tutte le sue voci sono diverse da zero e falsa in caso contrario. Provalo online!

Per verificare tutti i casi di test , ifviene aggiunto un ramo nel piè di pagina che sostituisce qualsiasi valore di verità con la stringa 'truthy'o qualsiasi valore di falsa con la stringa 'falsy', quindi visualizza la stringa.

Spiegazione

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

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

Provalo online! Questa interpretazione del problema è sorprendentemente competitiva.

Clojure, 115 byte

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

Costruisci una regex su ciascuna coppia di lettere e vedi se l'input corrisponde a una coppia. Molti modi più eleganti per fare tutte queste parti, ma sono tutti più prolissi. Questa è la vita con il golf Clojure.

Perl 5, 68 + 1 = 69 byte

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

Corri con -n.

Spiegazione:

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

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

Correre:

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^$è un combinatore che accetta un oggetto regex e restituisce una funzione che corrisponde a quel regex in modo ancorato. (Di per sé, un oggetto regex è un oggetto richiamabile da una funzione che prende una stringa e cerca se stesso attraverso di essa.)

Python 3 , 66 byte

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

Provalo online!

TXR : 78 74 byte

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

Esegui, dal prompt di sistema. Il numero nel prompt è stato di terminazione: 0 = successo, 1 = errore:

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

Spiegazione:

• @{x 2}: abbina due caratteri, associa alla xvariabile.
• @(rep :gap 0)@x@(end): corrispondenza ripetuta senza spazi saltati: zero o più occorrenze di x, il digraph precedentemente associato.
• @y: resto della riga corrispondente, catturato in y.
• @(bind(x y)(foo bar)): associa xa foo, y a bar. Poiché xe ysono già vincolati, devono corrispondere fooe bar, altrimenti, si verifica un errore.
• fooè #"nu un mw wm bq qb", una lista di parole letterale, zucchero sintattico per la lista di Lisp ("nu" "un" ... "qb"). Una bindcorrispondenza tra una variabile e un elenco indica che la variabile deve corrispondere a un elemento.
• barè @[x 0..1]: la sottostringa a un carattere di xdall'inizio. La bindcorrispondenza tra ye questo impone che l'ultima lettera della riga corrisponda alla prima.

C ++, 268 byte

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

Restituisce 1o 0.

Spiegazione

Tutte le stringhe di cartwheel avranno uno o più di bq , wm o un . Lo testiamo con:

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

Se sostituisci tutte le istanze delle prime due lettere di una stringa cartwheel con niente, rimarrai con la prima lettera della stringa. Lo testiamo 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