(참고 :이 쉽게 스핀 오프 내 이전의 도전입니다 ! Infinity (무한대) 단어를 찾기 스핀 오프 내 다른 이전의 도전 인 소용돌이 치는 단어를 찾아라! :))

파도 치는 단어의 정의 :

1. 알파벳 (AZ)에 물결 모양 단어 의 모든 문자를 곡선으로 연결 하면 아래 다이어그램과 같이 연속적으로 오른쪽 또는 왼쪽을 향하고 방향을 바꾸지 않는 물결의 경로를 얻을 수 있습니다.
2. 물결 모양의 말씀은 할 수 있습니다 :
   • 올리기 각 연속 문자 이전의 (알파벳)에 오른쪽에있는 경우.
   • 연속 된 각 문자가 이전 문자의 왼쪽 (알파벳)에 있으면 줄어 듭니다 .
3. 모든 짝수 연결이 작동 중지되어야하고 모든 홀수 연결이 작동해야합니다.
4. 대문자 / 소문자를 무시하거나 모두 대문자 또는 모두 소문자로 간주 / 변환 할 수 있습니다.
5. 입력 단어는 AZ의 알파벳 범위에있는 문자, 공백, 문장 부호 또는 기호가 아닙니다.
6. 단어에 "SPOON"과 같이 이중 문자가있는 경우 이중 문자를 "SPOON"> "SPON"으로 축소해야합니다 (O에서 O로 이동하면 거리가 0이므로).
7. 물결 모양의 단어 (복식이 붕괴 후에도) 적어도 3 개 별개의 문자가 포함됩니다.

몇 가지 예가 있습니다 :

직무:

표준 입력에서 단어를 가져와 Wavy Word 인 경우 출력하고 양수의 경우 증가 또는 감소 하는 경우 출력 되는 전체 프로그램 또는 함수를 작성하십시오 . 출력은 할 수있다 True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, 등, 당신은 그것을 표현하는 방법을 결정합니다.

테스트 사례 :

WAVY WORDS:
  ADEPT, BEGIN, BILL, BOSS, BOOST, CHIMP,
  KNOW, SPONGE, SPOON, TROLL, WOLF  

ADEPT  > YES > RAISING
BEGIN  > YES > RAISING
BILL   > YES > RAISING
BOSS   > YES > RAISING
BOOST  > YES > RAISING
CHIMP  > YES > RAISING
KNOW   > YES > RAISING
SPONGE > YES > DECREASING
SPOON  > YES > DECREASING
TROLL  > YES > DECREASING
WOLF   > YES > DECREASING

NOT WAVY WORDS:
  WATCH, EARTH, NINON, FOO, BAR, WAVE, SELECTION,
  YES, NO, DEFINITION, WATER, WINE, CODE, AAAHHHH, I, MM, ABCA

규칙 :

• 가장 짧은 코드가 승리합니다.

선택적 작업 :

영어 사전에서 가능한 많은 Wavy 단어 를 목록으로 찾을 수 있습니다. 당신은 참조로 예를 들면 영어 단어의 전체 목록을 취할 수 있습니다 여기에 .

05AB1E , 11 9 바이트 (Adnan에게 감사)

Dg2›iÇü‹Ù

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

물결 모양의 케이스 :

0- 물결 감소

1- 물결 증가

물결 모양이 아닌 경우 :

[0,1] -물결 모양이 아니고 처음에는 감소하지만 패턴을 깨는 증가 / 균등이 있습니다.

[1,0] -물결 모양이 아니고 처음에는 증가하지만 패턴을 깨는 감소 / 평등이 있습니다.

입력 문자열 -길이로 인해 처음에는 물결 모양 일 수 없습니다.

설명:

Dg2›iÇü‹Ù   # Full program

D           # Push 2 copies of input.
 g2›i       # If length is greater than 2. 
     Ç      # Push ASCII values for all characters in the string.
      ü     # Push pairwise array.
       ‹    # Vectorize 1 if negative difference, 0 if positive difference.
        Ù   # Uniquify using right most unique values first.
            # Else just print the string back, letting them know it's not valid input.

젤리 , 10 바이트

OIṠḟ0µL’aQ

TryItOnline! 또는 모든 테스트 사례를 실행

반환 값 :
[1]증가 물결에
[-1]물결 모양의 감소를 위해
다른 다른 뭔가 ( [], [0], [-1,1], 또는 [1,-1])

(필요로 선언들 각각에 대한 단일 값의 경우 OIṠḟ0µL’aQS(11 바이트)이 리턴 1, -1및 0각각).

어떻게?

OIṠḟ0µL’aQ - Main link: s
O          - cast to ordinals
 I         - incremental differences
  Ṡ        - sign (-1 for decreasing, 0 for no change, 1 for increasing)
   ḟ0      - filter out zeros
     µ     - monadic chain separation
      L    - length
       ’   - decremented
        a  - and
         Q - unique items

파이썬 2, 54 바이트

lambda s:[2<len(set(s))<s[::b]==sorted(s)for b in-1,1]

문자 목록으로 입력을받습니다. 출력 :

[False, True] for ascending
[True, False] for descending
[False, False] for neither

정렬 된 입력 문자열이 원래 또는 반대인지 확인합니다. 단계 크기를 1과 -1로 슬라이싱하면됩니다. 동시에, 우리는 단어에 적어도 2 개의 별개의 문자가 있는지 확인합니다.

"exit with error"가 두 경우 모두에 대한 출력으로 사용될 수 있다면, 우리는 51 바이트로 내려갈 수 있습니다 :

lambda s:[s,s[::-(len(set(s))>2)]].index(sorted(s))

파이썬 3, 77 75 바이트

lambda x:(len(set(x))>2)*(list(x)==sorted(x)or(list(x)==sorted(x)[::-1])*2)

모든 글자가 같은 경우를 가정합니다.

보고:

• 0 물결 모양이 아닌 경우
• 1 앞으로 물결 모양 인 경우
• 2 거꾸로 물결 경우

@ETHproductions 덕분에 불필요한 공간이 제거되었습니다.

R, 96 95 바이트

function(x,d=diff(rle(utf8ToInt(x))$v))if(any(d>0)&any(d<0)|sum(1|d)<2)3 else`if`(all(d<1),2,1)

보고:

• 1 물결 모양의 모금
• 2 물결 모양 및 감소 용
• 3 비 웨이브 용

설명

• d=diff(rle(utf8ToInt(x))$v): 편리하게 벡터를 반환하는 d문자열을 먼저 ASCII값 으로 변환하여 변수 를 생성합니다 utf8ToInt. 을 사용하여 실행 길이 인코딩을 수행하십시오 rle. rle(...)$v시퀀스의 반복되지 않는 값을 반환합니다 (즉, 모든 실행 축소). 마지막으로 차이를 가져 가십시오.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: 차이 중 하나 이상이 양수이고 하나 이상 음수이거나, 차이 시퀀스에 2요소 미만 (3 자 미만의 원래 단어와 동일)이있는 경우, 단어는 물결이 아니며 반환3
• else``if``(all(d<1),2,1): 모든 차이가 음수이면 2물결 모양과 감소로 돌아가고 그렇지 않으면 1물결 모양과 높이기 위해 돌아옵니다 .

R-fiddle 에서 모든 테스트 사례를 시도하십시오 (테스트 사례에 맞게 벡터화 할 수 있도록 이름이 지정되어 있음).

자바 스크립트 (ES6), 84 81 바이트

s=>(new Set(t=[...s]).size>2)*(!t.some((c,i)=>c>s[i+1])-!t.some((c,i)=>c<s[i+1]))

입력이 모두 같은 경우라고 가정합니다. 1물결 모양을 올리 거나 -1, 물결 모양을 0줄이거 나 , 물결 모양 -0이 아닌 경우 (모두 거짓) 반환 합니다 . 편집 : @RobertHickman 덕분에 3 바이트가 절약되었습니다.

자바 스크립트 (ES6), 84 80 78 바이트

i=>new Set(s=[...i]).size>2?[i,s.reverse().join``].indexOf(s.sort().join``):-1

물결 모양 증가가 0이면 감소는 1이고 -1은 물결 모양이 아닙니다.

2 바이트를 절약 할 수 있도록 @Neil 에게 감사드립니다 .

Pyth, 12 바이트

x*<2lrQ8_BQS

온라인으로 사용해보십시오. 테스트 스위트.

파이썬 2, 53 52 50 바이트

따옴표로 묶은 입력을 예상합니다. 예 : "watch"

명명되지 않은 람다 :

lambda s:(sum(map(cmp,s[1:],s))+1)/min(len(s)-1,3)

각 문자와 정수로 나누는 차이의 부호를로 나눕니다 len-1. 모든라면 1합인 (증가) len-1그것을 표시 1감소시키기위한 유사하게, -1혼합을 위해 1, -1합보다 작은 len-1것이 표시 그래서 0.

로 변경 cmp,s[1:],s[:-1])하기 위한 -1 바이트cmp,s[1:],s)+1

루비, 54 바이트

->w{c=w.chars.uniq;c==(s=c.sort)?2:(c==s.reverse)?1:0}

반환 0단어, 물결 모양이 아닌 경우 1뒤로 물결 모양의 경우, 및 2경우 전달 물결 모양.

그루비-56 바이트

{d = it [0]; c = [0] * 3; it.each {a-> c [(a <=> d)] = 1; d = a}; c [1 ..- 1]}

단일 문자 입력 또는 비 물결 [1,0]모양을위한 물결 모양 올리기, 물결 모양 [0,1]줄이기 , 출력 .[0,0][1,1]

참고 : 입력이 문자열 또는 char []이고 모든 문자가 동일한 경우를 가정합니다.

PHP, 96 바이트

for(;($t=$argv[1])[++$i];)$s+=$r[]=$t[$i-1]<=>$t[$i];echo(max($r)-min($r)<2)*(0<=>$s)*(1<$s*$s);

또는 98 바이트

$s=str_split($t=$argv[1]);sort($s);echo(-($t==strrev($j=join($s)))|$t==$j)*!!count_chars($t,3)[2];

0 물결 모양 없음 1 증가 -1 감소

PHP, 100 바이트

$n=$m=$l=str_split($argv[1]);sort($n);rsort($m);echo(($n==$l)-($m==$l))*(count(array_unique($l))>2);

보고:

• -1 물결 모양의 감소.
• 0 물결 모양이 아닙니다.
• 1 물결 모양으로 키우기 위해.

C, 164 바이트

main(){char s[99];scanf("%s",s);char *c=&s;int p=*c;while(*c^0){if(p>*c){if(c-&s[0]>1)return 0;while(*c^0){if(p<*c)return 0;p=*c;c++;}return 2;}p=*c;c++;}return 1;}

wawy가 아닌 경우 0, wawy 및 높이면 1, 감소하면 2를 반환합니다.

라켓 321 바이트

(let*((ld(λ(sl)(for/list((i(sub1(length sl))))(-(list-ref sl(add1 i))(list-ref sl i)))))(l(ld(remove-duplicates(map
(λ(x)(char->integer x))(string->list s)))))(am andmap)(N"Not WAVY")(d displayln))(cond[(<(length l)2)(d N)][(am(λ(x)(>= x 0))l)
(d"YES; RAISING")][(am(λ(x)(<= x 0))l)(d"YES; DECREASING")][else(d N)])))

언 골프 드 :

(define (f s)
  (let*  ((ld (lambda(sl)          ; sub-fn to get differences in list elements
                (for/list ((i (sub1(length sl))))
                  (- (list-ref sl (add1 i))
                     (list-ref sl i) ) )))
          (l (ld
              (remove-duplicates
               (map
                (lambda(x)
                  (char->integer x))
                (string->list s)))))
          (am andmap)
          (N "Not WAVY")
          (d displayln))
    (cond
      [(< (length l) 2)(d N)]
      [(am (lambda(x) (>= x 0)) l) (d "YES; RAISING")]
      [(am (lambda(x) (<= x 0)) l) (d "YES; DECREASING")]
      [else (d N)]
      )))

테스트 :

(f "ADEPT"); > YES > RAISING
(f "BEGIN"); > YES > RAISING
(f "BILL"); > YES > RAISING
(f "BOSS"); > YES > RAISING
(f "BOOST"); > YES > RAISING
(f "CHIMP"); > YES > RAISING
(f "KNOW"); > YES > RAISING
(f "SPONGE"); > YES > DECREASING
(f "SPOON"); > YES > DECREASING
(f "TROLL"); > YES > DECREASING
(f "WOLF"); > YES > DECREASING

(f "WATCH")
(f "EARTH")
(f "NINON")
(f "FOO")
(f "BAR")
(f "WAVE")
(f "SELECTION")

산출:

YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; DECREASING
YES; DECREASING
YES; DECREASING
YES; DECREASING
Not WAVY
Not WAVY
Not WAVY
Not WAVY
Not WAVY
Not WAVY
Not WAVY

자바 7, 254 240 바이트

import java.util.*;int c(String s){char[]a=s.toCharArray(),x=a.clone();Arrays.sort(x);return s.replaceAll("(.)\\1{1,}","$1").length()<3?0:Arrays.equals(a,x)|Arrays.equals(x,(new StringBuffer(s).reverse()+"").toCharArray())?a[0]>a[1]?1:2:0;}

0입력 문자열이 물결 모양이 아닌 1경우, 상승 물결 인 2경우 및 감소 하는 물결 인 경우 출력 합니다 .

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

import java.util.*;
class M{
  static int c(String s){
    char[] a = s.toCharArray(),
           x = a.clone();
    Arrays.sort(x);
    return s.replaceAll("(.)\\1{1,}", "$1").length() < 3
            ? 0
            : Arrays.equals(a, x) | Arrays.equals(x, (new StringBuffer(s).reverse()+"").toCharArray())
               ? a[0] > a[1]
                  ? 1
                  : 2
               : 0;
  }

  public static void main(String[] a){
    System.out.print(c("ADEPT") + ", ");
    System.out.print(c("BEGIN") + ", ");
    System.out.print(c("BILL") + ", ");
    System.out.print(c("BOSS") + ", ");
    System.out.print(c("BOOST") + ", ");
    System.out.print(c("CHIMP") + ", ");
    System.out.println(c("KNOW"));

    System.out.print(c("SPONGE") + ", ");
    System.out.print(c("SPOON") + ", ");
    System.out.print(c("TROLL") + ", ");
    System.out.println(c("WOLF"));

    System.out.print(c("WATCH") + ", ");
    System.out.print(c("EARTH") + ", ");
    System.out.print(c("NINON") + ", ");
    System.out.print(c("FOO") + ", ");
    System.out.print(c("BAR") + ", ");
    System.out.print(c("WAVE") + ", ");
    System.out.print(c("SELECTION") + ", ");
    System.out.print(c("YES") + ", ");
    System.out.print(c("NO") + ", ");
    System.out.print(c("DEFINITION") + ", ");
    System.out.print(c("WATER") + ", ");
    System.out.print(c("WINE") + ", ");
    System.out.print(c("CODE") + ", ");
    System.out.print(c("AAAHHHH") + ", ");
    System.out.print(c("I") + ", ");
    System.out.print(c("MM") + ", ");
    System.out.println(c("ABCA"));
  }
}

산출:

2, 2, 2, 2, 2, 2, 2
1, 1, 1, 1
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0