(Lưu ý: đây là phần phụ dễ dàng hơn trong thử thách trước đây của tôi Tìm từ vô cực!, Đây là phần phụ của thử thách trước đó của tôi Tìm từ ngữ xoáy! :))

Định nghĩa của một từ lượn sóng :

1. Nếu bạn kết nối với các đường cong tất cả các ký tự của Word lượn sóng trên bảng chữ cái (AZ), bạn sẽ có được đường đi của sóng liên tục sang phải hoặc sang trái và không bao giờ thay đổi hướng, như trong sơ đồ bên dưới.
2. Một từ lượn sóng có thể là:
   • Tăng nếu mỗi ký tự liên tiếp ở bên phải (trên bảng chữ cái) của ký tự trước.
   • Giảm nếu mỗi ký tự liên tiếp ở bên trái (trên bảng chữ cái) của ký tự trước.
3. Tất cả các kết nối chẵn phải xuống, tất cả các kết nối lẻ phải được lên.
4. Bạn có thể bỏ qua chữ hoa / chữ thường hoặc xem xét / chuyển đổi tất cả sang chữ hoa hoặc tất cả sang chữ thường.
5. Các từ đầu vào chỉ là các ký tự trong phạm vi bảng chữ cái của AZ, không có dấu cách, không có dấu chấm câu hoặc ký hiệu.
6. Nếu một từ có hai ký tự, như "SPOON", bạn phải thu gọn số nhân đôi thành một ký tự: "SPOON"> "SPON" (vì nếu bạn đi từ O đến O thì khoảng cách bằng 0).
7. Các từ lượn sóng sẽ chứa ít nhất 3 ký tự riêng biệt (ngay cả sau khi nhân đôi sự sụp đổ).

Dưới đây là một số ví dụ:

Bài tập:

Viết một chương trình hoặc hàm đầy đủ sẽ lấy một từ từ đầu vào tiêu chuẩn và sẽ xuất ra nếu đó là một từ lượn sóng hay không, và trong trường hợp tích cực, đầu ra nếu nó tăng hoặc giảm . Sản lượng có thể True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, vv, bạn quyết định làm thế nào để thể hiện nó.

Các trường hợp thử nghiệm:

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

Quy tắc:

• Mã ngắn nhất sẽ thắng.

Nhiệm vụ tùy chọn:

Tìm, như một danh sách, càng nhiều từ lượn sóng càng tốt trong từ điển tiếng Anh, và từ dài nhất cũng vậy. Bạn có thể lấy ví dụ như tham khảo danh sách đầy đủ các từ tiếng Anh ở đây .

05AB1E , 11 9 byte (Cảm ơn Adnan)

Dg2›iÇü‹Ù

Hãy thử trực tuyến!

Trường hợp lượn sóng:

0 - Giảm gợn sóng

1 - Tăng gợn sóng

Không phải trường hợp lượn sóng:

[0,1] - Không lượn sóng, ban đầu giảm, nhưng sau đó có sự tăng / bình đẳng đã phá vỡ mô hình.

[1,0] - Không lượn sóng, ban đầu tăng, nhưng sau đó giảm / bình đẳng đã phá vỡ mô hình

Chuỗi đầu vào - Không thể lượn sóng ở vị trí đầu tiên do độ dài.

Giải trình:

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.

Thạch , 10 byte

OIṠḟ0µL’aQ

Dùng thử trực tuyến! hoặc chạy tất cả các trường hợp thử nghiệm

Returns:
[1]cho gợn sóng tăng
[-1]cho gợn sóng giảm
cái gì khác khác ( [], [0], [-1,1], hay [1,-1])

(Tuyên bố như thế không cần thiết: Để có một giá trị duy nhất cho mỗi OIṠḟ0µL’aQS(11 byte) sẽ trở lại 1, -1và 0lần lượt.)

Làm sao?

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 byte

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

Đưa đầu vào dưới dạng danh sách các ký tự. Đầu ra:

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

Kiểm tra xem chuỗi đầu vào được sắp xếp bằng với gốc hay ngược của nó. Làm như vậy bằng cách cắt với kích thước bước 1 và -1. Đồng thời, chúng tôi kiểm tra xem từ đó có ít nhất 2 chữ cái riêng biệt hay không.

Nếu "thoát có lỗi" có thể được sử dụng một đầu ra cho cả hai trường hợp, chúng ta có thể giảm xuống 51 byte:

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

Python 3, 77 75 byte

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

Giả sử tất cả các chữ cái là của cùng một trường hợp.

Trả về:

• 0 nếu không lượn sóng
• 1 nếu chuyển tiếp lượn sóng
• 2 nếu lượn sóng ngược

Đã xóa các khoảng trống không cần thiết nhờ @ETHproductions

R, 96 95 byte

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)

Trả về:

• 1 cho lượn sóng và nâng cao
• 2 cho lượn sóng và giảm
• 3 cho không lượn sóng

Giải thích

• d=diff(rle(utf8ToInt(x))$v): Tạo một biến dbằng cách trước tiên chuyển đổi chuỗi thành ASCIIgiá trị của nó bằng cách sử dụng utf8ToIntthuận tiện trả về một vectơ. Sau đó thực hiện mã hóa chiều dài chạy bằng cách sử dụng rle. rle(...)$vtrả về các giá trị không lặp lại của chuỗi (nghĩa là thu gọn tất cả các lần chạy). Cuối cùng lấy sự khác biệt.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Nếu ít nhất một trong các khác biệt là dương và ít nhất một âm hoặc nếu chuỗi khác biệt có ít hơn 2các phần tử (tương đương với từ gốc có ít hơn 3 ký tự), từ đó không bị lượn sóng và trả về3
• else``if``(all(d<1),2,1): Khác nếu tất cả các khác biệt là âm, trả lại 2cho lượn sóng và giảm, khác trả lại 1cho lượn sóng và nâng cao.

Hãy thử tất cả các trường hợp thử nghiệm tại R-fiddle (lưu ý rằng nó được đặt tên sao cho nó có thể được vector hóa cho các trường hợp thử nghiệm).

JavaScript (ES6), 84 81 byte

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

Giả sử đầu vào là tất cả trong cùng một trường hợp. Trả về 1cho việc tăng gợn sóng, -1để giảm gợn sóng, 0hoặc -0(cả hai đều là giả) cho không lượn sóng. Chỉnh sửa: Đã lưu 3 byte nhờ @RobertHickman.

Javascript (ES6), 84 80 78 byte

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

Trong đó độ lượn sóng tăng là 0, giảm là 1 và -1 không phải là lượn sóng.

Cảm ơn @Neil đã giúp tôi tiết kiệm 2 byte.

Bình thường, 12 byte

x*<2lrQ8_BQS

Hãy thử trực tuyến. Bộ thử nghiệm.

Python 2, 53 52 50 byte

Mong đợi đầu vào kèm theo trong ngoặc kép, vd "watch"

Như lambda chưa được đặt tên:

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

Tính tổng các dấu hiệu khác nhau giữa mỗi chữ cái và số nguyên chia cho len-1. Nếu tất cả là 1(tăng) thì tổng là len-1nó hiển thị 1, tương tự như giảm -1và đối với hỗn hợp 1, -1tổng nhỏ hơn so với số tiền len-1hiển thị 0.

-1 byte để thay đổi cmp,s[1:],s[:-1])thànhcmp,s[1:],s)+1

Ruby, 54 byte

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

Trả về 0nếu từ không lượn sóng, 1nếu lượn sóng ngược và 2nếu chuyển tiếp lượn sóng.

Groovy - 56 byte

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

Đầu ra [1,0]để tăng độ lượn sóng, [0,1]để giảm độ lượn sóng, [0,0]cho đầu vào ký tự đơn hoặc [1,1]không lượn sóng.

LƯU Ý: Giả sử đầu vào là Chuỗi hoặc char [] và tất cả các chữ cái đều thuộc cùng một trường hợp.

PHP, 96 byte

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

hoặc 98 byte

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

0 không lượn sóng 1 tăng -1 giảm

PHP, 100 byte

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

Trả về:

• -1 cho lượn sóng, giảm dần.
• 0 cho không lượn sóng.
• 1 cho lượn sóng, nâng cao.

C, 164 byte

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

Trả về 0 nếu không wawy, 1 nếu wawy và nâng, 2 nếu giảm.

Vợt 321 byte

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

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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 byte

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

Đầu ra 0nếu chuỗi đầu vào không lượn sóng, 1nếu đó là sóng tăng và 2nếu đó là sóng giảm.

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

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"));
  }
}

Đầu ra:

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