（注意：这是我之前的挑战“ 找到无限的单词！”的一个简单衍生品，这是我之前的其他挑战“ 找到旋转的单词！”的一个衍生产品：））

波浪字的定义：

1. 如果您用曲线连接字母（AZ）上的波浪字的所有字符，您将获得不断向右或向左而不改变方向的波浪路径，如下图所示。
2. 一个波浪字可以是：
   • 提高每个连续字符是否在前一个字符的右侧（字母上）。
   • 减少每个连续字符是否在前一个字符的左侧（字母上）。
3. 所有偶数连接必须断开，所有奇数连接必须断开。
4. 您可以忽略大写/小写或全部考虑/转换为大写或全部转换为小写。
5. 输入的单词仅是AZ字母范围内的字符，没有空格，标点符号或符号。
6. 如果单词包含双精度字符，例如“ SPOON”，则必须将双精度折叠为一个字符：“ SPOON”>“ SPON”（因为从O到O的距离为零距离）。
7. 该波浪词将含有至少3个不同的字符（双打塌陷甚至之后）。

这里有一些例子：

任务：

编写一个完整的程序或函数，该函数将从标准输入中提取一个单词，如果不是波浪形单词，则将输出，如果是波浪形单词，则将其输出；如果是上升或下降，则将输出。输出可以是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

规则：

• 最短的代码胜出。

可选任务：

作为列表，在英语词典中查找尽可能多的波浪词，并且最长。例如，您可以在此处参考英语单词的完整列表。

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

Python 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个不同的字母。

如果两种情况都不能使用“错误退出”，则可以减少到51个字节：

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

Python 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上尝试所有测试用例（请注意，它的命名方式使其可以针对测试用例进行矢量化处理）。

JavaScript（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个字节。

Javascript（ES6），84 80 78字节

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

波浪状增加为0，减少为1，而-1则不是波浪状。

感谢@Neil帮助我节省了2个字节。

Pyth，12个字节

x*<2lrQ8_BQS

在线尝试。 测试套件。

Python 2，53 52 50字节

期望输入用引号引起来，例如 "watch"

作为未命名的lambda：

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。

-1字节用于更改cmp,s[1:],s[:-1])为cmp,s[1:],s)+1

Ruby，54个字节

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

0如果单词不是波浪形，1向后波浪形和2向前波浪形，则返回该单词。

Groovy-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]用于非波状。

注意：假设输入是String或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;}

如果不是波浪状，则返回0；如果波浪状且上升，则返回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

Java 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