(Catatan: ini adalah spin-off yang lebih mudah dari tantangan saya sebelumnya Find the Infinity Words ! , yang merupakan spin-off dari tantangan saya sebelumnya yang lain Find the Swirling Words! :))

Definisi Kata yang Berombak :

1. Jika Anda terhubung dengan kurva semua karakter dari Word Wavy pada alfabet (AZ), Anda mendapatkan jalur gelombang yang terus-menerus mengarah ke kanan atau ke kiri dan tidak pernah berubah arah, seperti pada diagram di bawah ini.
2. Sebuah Bergelombang Kata dapat:
   • Pemeliharaan jika masing-masing karakter berturut-turut di sebelah kanan (pada alfabet) dari yang sebelumnya.
   • Mengurangi jika setiap karakter berturut-turut adalah di sebelah kiri (pada alfabet) dari yang sebelumnya.
3. Semua koneksi genap harus turun, semua koneksi aneh harus naik.
4. Anda dapat mengabaikan huruf besar / kecil atau mempertimbangkan / mengonversi semua menjadi huruf besar atau semua ke huruf kecil.
5. Kata-kata input hanya karakter dalam rentang alfabet AZ, tanpa spasi, tanpa tanda baca, atau simbol.
6. Jika sebuah kata memiliki karakter ganda, seperti "SPOON", Anda harus menutup ganda menjadi satu karakter: "SPOON"> "SPON" (karena jika Anda pergi dari O ke O adalah jarak nol).
7. The Bergelombang Kata akan berisi minimal 3 karakter yang berbeda (bahkan setelah ganda runtuh).

Berikut ini beberapa contohnya:

Tugas:

Tulis program penuh atau fungsi yang akan mengambil kata-kata dari standar input dan output akan jika itu adalah Bergelombang Firman atau tidak, dan dalam hal positif, keluaran jika menaikkan atau menurunkan . Output bisa True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, dll, Anda memutuskan bagaimana untuk mewakilinya.

Kasus uji:

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

Aturan:

• Kode terpendek menang.

Tugas Opsional:

Temukan, sebagai daftar, sebanyak mungkin Wavy Words dalam kamus bahasa Inggris, dan juga yang terpanjang. Anda dapat mengambil contoh sebagai referensi daftar lengkap kata-kata bahasa Inggris di sini .

05AB1E , 11 9 byte (Terima kasih kepada Adnan)

Dg2›iÇü‹Ù

Cobalah online!

Kasus bergelombang:

0 - Mengurangi Bergelombang

1 - Meningkatkan Bergelombang

Bukan Kasus Bergelombang:

[0,1] - Tidak bergelombang, awalnya menurun, tetapi kemudian memiliki peningkatan / kesetaraan yang mematahkan pola.

[1,0] - Tidak bergelombang, awalnya meningkat, tetapi kemudian memiliki penurunan / kesetaraan yang mematahkan pola

Input String - Tidak mungkin bergelombang di tempat pertama karena panjang.

Penjelasan:

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.

Jelly , 10 byte

OIṠḟ0µL’aQ

TryItOnline! atau jalankan semua test case

Pengembalian:
[1]untuk bergelombang meningkat
[-1]untuk bergelombang menurun
sesuatu yang lain sebaliknya ( [], [0], [-1,1], atau [1,-1])

(Dinyatakan sebagai tidak perlu: Untuk nilai tunggal untuk setiap OIṠḟ0µL’aQS(11 bytes) akan kembali 1, -1dan 0masing-masing.)

Bagaimana?

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]

Mengambil input sebagai daftar karakter. Output:

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

Cek apakah string input yang diurutkan sama dengan aslinya atau terbalik. Lakukan dengan mengiris dengan ukuran langkah 1 dan -1. Pada saat yang sama, kami memeriksa apakah kata tersebut memiliki setidaknya 2 huruf berbeda.

Jika "keluar dengan kesalahan" dapat digunakan sebagai output untuk kedua kasus, kita dapat turun ke 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)

Asumsikan semua huruf dari kasus yang sama.

Pengembalian:

• 0 jika tidak bergelombang
• 1 jika ke depan bergelombang
• 2 jika mundur bergelombang

Ruang yang tidak perlu dihapus terima kasih @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)

Pengembalian:

• 1 untuk bergelombang dan membesarkan
• 2 untuk bergelombang dan menurun
• 3 untuk non-bergelombang

Dijelaskan

• d=diff(rle(utf8ToInt(x))$v): Menghasilkan variabel ddengan terlebih dahulu mengubah string menjadi ASCIInilai - nilai itu menggunakan utf8ToIntyang dengan mudah mengembalikan vektor. Selanjutnya melakukan pengkodean run length menggunakan rle. rle(...)$vmengembalikan nilai-nilai yang tidak berulang dari urutan (yaitu runtuh semua proses) Akhirnya ambil perbedaannya.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Jika setidaknya salah satu perbedaannya positif dan setidaknya satu negatif, atau jika urutan perbedaannya kurang dari 2elemen (setara dengan kata aslinya yang memiliki kurang dari 3 karakter), kata tersebut tidak bergelombang dan kembali3
• else``if``(all(d<1),2,1): Lain jika semua perbedaan negatif, kembali 2untuk bergelombang dan menurun, jika tidak kembali 1untuk bergelombang dan membesarkan.

Coba semua test case di R-fiddle (perhatikan bahwa ini dinamai sedemikian sehingga dapat di-vectorized untuk test case).

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

Mengasumsikan input semuanya dalam kasus yang sama. Pengembalian 1untuk menaikkan bergelombang, -1untuk mengurangi bergelombang, 0atau -0(keduanya palsu) karena tidak bergelombang. Sunting: Disimpan 3 byte berkat @RobertHickman.

Javascript (ES6), 84 80 78 byte

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

Di mana peningkatan bergelombang adalah 0, penurunan adalah 1, dan -1 tidak bergelombang.

Terima kasih kepada @Neil karena membantu saya menghemat 2 byte.

Pyth, 12 byte

x*<2lrQ8_BQS

Cobalah online. Suite uji.

Python 2, 53 52 50 byte

Diharapkan input terlampir dalam tanda kutip, mis "watch"

Sebagai lambda yang tidak disebutkan namanya:

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

Menjumlahkan tanda perbedaan antara setiap huruf dan bilangan bulat-dibagi len-1. Jika semua 1(meningkat) jumlah yang len-1ditampilkan 1, mirip untuk menurun -1dan untuk campuran 1, -1jumlahnya lebih kecil daripada len-1yang ditampilkan0 .

-1 byte untuk diubah cmp,s[1:],s[:-1])menjadicmp,s[1:],s)+1

Ruby, 54 byte

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

Mengembalikan 0jika kata tidak bergelombang, 1jika mundur bergelombang, dan2 jika maju bergelombang.

Groovy - 56 byte

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

Output [1,0]untuk meningkatkan bergelombang,[0,1] untuk mengurangi bergelombang, [0,0]untuk input karakter tunggal atau[1,1] untuk non-bergelombang.

CATATAN: Mengasumsikan input berupa String atau karakter [] dan semua huruf memiliki huruf yang sama.

PHP, 96 Bytes

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

atau 98 Bytes

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

0 tidak bergelombang 1 kenaikan -1 menurun

PHP, 100 byte

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

Pengembalian:

• -1 untuk bergelombang, menurun.
• 0 karena tidak bergelombang.
• 1 untuk bergelombang, membesarkan.

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

Mengembalikan 0 jika tidak wawy, 1 jika wawy dan membesarkan, 2 jika menurun.

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

Tidak Disatukan:

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

Pengujian:

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

Keluaran:

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

Output 0jika string input tidak bergelombang, 1jika itu gelombang penaikan, dan2 jika itu gelombang yang menurun.

Tidak digabungkan & kode uji:

Coba di sini.

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

Keluaran:

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