도전 영감은 내가 어딘가에서 본 것입니다.

"nun"이라는 단어 는 수레 바퀴를 하는 문자 n입니다.

당신의 도전은 문자열을 가지고 그것이 수레 바퀴를하는 첫 글자인지 확인하는 것입니다.

규칙

다음과 같은 경우 문자열은 수레 바퀴를 수행하는 문자입니다.

• 첫 글자는 마지막 글자와 같습니다. (그 편지는 머리에 닿을 수 없습니다.)
• 문자열은 한 문자마다 카트 바퀴 문자 사이를 번갈아 표시합니다.

수레 바퀴 문자는 n및 u, m및 w, b및 q입니다. 참고한다는 n와 w함께이되어 있지 편지를 cartwheeling하고, 둘은 없습니다 w와 b.

• 표준 입력 방법 중 하나를 사용하여 문자열을 가져옵니다.
• 문자열이 수레 바퀴 문자이면 틀린 값을 출력하고 그렇지 않으면 거짓 값을 출력합니다. 표준 출력 방법을 사용하여 출력 할 수 있습니다.

추가 규칙 :

• 소문자 수레 바퀴 문자 n/ u/ m/ w/ b/ q만 처리하면됩니다.
• 입력이 비어 있지 않다고 가정 할 수 있습니다.
• 한 문자 문자열은 올바른 수레 바퀴가 아닙니다.

테스트 사례

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

우승자

와 마찬가지로 코드 골프 (각 언어에서) 가장 짧은 코드가 승리!

젤리 , 23 바이트

_{생각보다 많은 작업이 필요했습니다!}

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

문자 목록을 가져 와서 1(truthy) 또는 0(falsey)를 반환하는 monadic 링크 .

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

1- 인덱싱 된 문자 목록에서 입력의 각 문자의 색인을 찾습니다 nmbuwq. 이 문자열은 유효한 수레 바퀴에 대한 인덱스의 증분 차이가 [-3,3]또는 중 하나의 반복이므로 쌍의 인덱스가 3 개가되도록 배열됩니다 [3,-3].

항목이 원자은 "지수"가 목록에없는 경우 i, 그것은 반환 0과 발견되지 않은 문자 쌍 것이다 b같이 입력을하고, bxbxbtruthy. 따라서 0s는 10유효성을 검사하기 전에 다른 값에서 3보다 큰 값 으로 대체됩니다 .

“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 바이트

첫 줄을 단축하여 @Neil 덕분에 12 바이트 절약

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

온라인으로 사용해보십시오!

거짓 인 경우 입력을 삭제하고 그렇지 않으면 입력에 아무 것도 수행하지 않습니다.

설명

로 -r플래그, 우리는 사용할 필요가 없습니다 \(및 \)그룹을 캡처하고이 바이트를 저장합니다.

/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

자바 스크립트 (ES6), 82 78 77 바이트

ThePirateBay 및 MD XF에서 제안한대로 두 개의 잘못된 값을 사용하여 1 바이트를 절약했습니다.

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

테스트 사례

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

파이썬 3 , 111 바이트

Mr. Xcoder 덕분에 -2 바이트.

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

온라인으로 사용해보십시오!

파이썬 2 , 63 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 71 바이트

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

온라인으로 사용해보십시오!

@HyperNeutrino -1 감사 -13 @ovs 덕분에

위의 모든 테스트 사례에서 실패한 것으로 판명되면 대안이 있습니다.

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

온라인으로 사용해보십시오!

설명

• ''.join(sorted(list({*n[1::2]}).union({*n[::2]})))) -홀수 인덱스의 문자와 짝수 인덱스의 문자를 가져 와서 중복 제거하고 조합에 의해 형성된 목록을 정렬합니다.

• in'nu,mw,bq' -유효한 장바구니 문자 조합인지 확인합니다.

• n[0]==n[-1] -첫 글자가 마지막 글자와 같은지 확인합니다.

자바 스크립트 (ES6), 40 바이트

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

입력 문자열의 두 번째 문자와 연결된 입력 문자열이 동일한 수레 바퀴 문자 쌍의 반복 문자열인지 확인합니다.

테스트 :

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

클로저, 156 바이트

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

이것은 매우 어려웠다! 나는 그것을 3 가지 하위 문제로 분해해야했습니다.

• 첫 글자는 마지막 글자와 동일합니까?
• 글자가 반복됩니까?
• 모든 문자가 유효한 세트 중 하나의 일부입니까?

나는 확실히 이기지 못했다. 그러나 이것은 좋은 아침 운동이었다! 아래 전체 설명 :

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

하스켈, 80 78 바이트

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

온라인으로 사용해보십시오!

작동 방식 :

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

파이썬 2 , 45 바이트

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

온라인으로 사용해보십시오!

문자열의 공백은 DEL문자입니다.

레티 나 , 24 바이트

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

진실의 경우 1을, 거짓의 경우 0을 출력합니다.

소의 포트 ck의 대답.

온라인으로 사용해보십시오!

Grime , 28 바이트

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

온라인으로 사용해보십시오! 인쇄 1truthy 입력 및 0falsy 사람을위한.

설명

Grime 구문은 정규식과 비슷하며 Grime 프로그램은 문자의 사각형과 일치하거나 일치하지 않는 패턴을 지정합니다.

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.

이를 단축시키는 데 도움이되는 Grime의 일부 기능 :

• 일반적으로 문자 리터럴은 백 슬래시로 이스케이프해야하지만 다음과 같이 ""변경합니다. 구문 요소는 이스케이프되지만 리터럴은 그렇지 않습니다. 따옴표가 없으면 문자 쌍을 열거하는 부분은입니다 (\n\u|\b\p|\m\w)oT.
• 이항 연산자 (여기 -) 를 따르는 단항 연산자는 다음과 같이 결과에 작용 ..-#!"…"oT합니다 (..-"…"oT)#!.
• v들 그들을 따라 구문 요소의 우선 순위를 낮 춥니 다. 고독한는 &보다 더 높은 우선 순위를 가지고 있습니다 -만, v&낮은있다. 마찬가지로 ..+으로 구문 분석 .(.+)되지만 ..v+과 동일합니다 (..)+.

파이썬 2 , 69 바이트

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

온라인으로 사용해보십시오!

Pyth , 27 바이트

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

테스트 스위트.

OP가 채팅에서 허용 한대로 진실 하거나 1허위로 출력 합니다 .False0

젤리 , 27 바이트

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

온라인으로 사용해보십시오!

작동 원리

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

파이썬 2 , 103 바이트

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]

온라인으로 사용해보십시오!

apt , 47 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 88 바이트

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: 짝수 길이의 문자열은 첫 번째 문자로 끝날 수 없습니다

x[:2] in: 6 개의 유효한 시작 쌍이 있는지 확인하십시오.

len(set()): 0,2,4 ... 및 1,3,5 ...에서 문자 집합의 길이를 가져옵니다.

True평가 목록이 [1,1,1,1]과 같으면 else를 반환 합니다 False.

온라인으로 사용해보십시오!

Perl 5 , 55 + 1 (-p) = 56 바이트

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

온라인으로 사용해보십시오!

첫 번째 문자의 "거꾸로"버전을 true로 인쇄하고 false를 표시하지 않습니다.

PHP, 59 + 1 바이트

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

로 파이프로 실행하십시오 -F.

부분적으로 정규식 솔루션, 101 + 1 바이트 :

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

허위 출력이 비어 있습니다. 로 파이프로 실행하십시오 -nR.

자바 8, 57 바이트

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

여기에서 시도하십시오.

6 가지 경우 모두에 맞는 간단한 정규식. Java String#matches는 전체 문자열과 자동으로 일치하므로 필요하지 않습니다 ^...$.

MATL , 25 바이트

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

OUPUT는 비어 있지 않은 숫자 열 벡터이다 truthy 모든 항목이 0이고, 경우 falsy 그렇지. 온라인으로 사용해보십시오!

하기 위해 모든 테스트 케이스를 확인 , if분기 문자열이 어떤 truthy 값을 대체 바닥 글에 추가 'truthy'또는 문자열에 의한 falsy 값 'falsy', 다음 문자열을 표시합니다.

설명

'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

파이썬 2 , 74 바이트

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

온라인으로 사용해보십시오! 이 문제에 대한 이의 제기는 놀랍도록 경쟁력이 있습니다.

클로저, 115 바이트

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

각 문자 쌍으로 정규식을 작성하고 입력이 일치하는지 확인하십시오. 이 모든 부분을 수행하는 더 많은 우아한 방법이 있지만 모두 더 장황합니다. 클로저 골프와 같은 삶입니다.

Perl 5, 68 + 1 = 69 바이트

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

로 실행하십시오 -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 리스프 , 50 바이트

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

운영:

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^$정규식 객체를 가져와 고정 된 방식으로 정규식과 일치하는 함수를 반환하는 결합기입니다. (그 자체로 정규 표현식 객체는 문자열을 가져 와서 스스로 검색하는 함수 호출 객체입니다.)

파이썬 3 , 66 바이트

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

온라인으로 사용해보십시오!

TXR : 78 74 바이트

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

시스템 프롬프트에서 실행하십시오. 프롬프트의 숫자는 종료 상태입니다 : 0 = 성공, 1 = 실패 :

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

설명:

• @{x 2}: 두 문자와 일치하고 x변수에 바인드 합니다.
• @(rep :gap 0)@x@(end): 건너 뛴 간격없이 반복 일치 : x이전에 일치 한 digraph가 0 회 이상 발생 합니다.
• @y: 나머지 줄이 일치하여로 캡처되었습니다 y.
• @(bind(x y)(foo bar)): 바인드 x행 foo내지 y bar. 이후 x와 y이미 결합되어, 그들은 일치해야 foo하고 bar, 그렇지 않으면 실패가있다.
• foo인 #"nu un mw wm bq qb"단어 목록의 문자, 리스프 목록에 대한 문법 설탕은 ("nu" "un" ... "qb"). bind변수와 변수 요소와 일치해야리스트 수단 간의 매치.
• baris @[x 0..1]: x시작 부분의 한 문자 하위 문자열입니다 . bind과 사이 의 일치 y는 줄의 마지막 문자가 첫 번째 문자와 일치하도록합니다.

C ++, 268 바이트

#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;}

자바 스크립트 (ES6), 63 바이트

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

반환 1또는 0.

설명

모든 수레 바퀴 문자열에는 bq , wm 또는 un 중 하나 이상이 있습니다 . 우리는 다음과 같이 테스트합니다.

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

수레 바퀴 문자열의 처음 두 글자를 모두 아무것도 바꾸지 않으면 문자열의 첫 글자가 남습니다. 우리는 다음과 같이 테스트합니다.

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