(Not: Bu benim önceki meydan okuma daha kolay bir spin- in Sonsuzluk Kelimeleri Bul!, Önceki diğer meydan okuma bir spin- up Dönen Kelimeleri Bul! :))

Dalgalı Bir Kelimenin Tanımı :

1. Alfabedeki (AZ) bir Dalgalı Sözün tüm karakterlerini eğrilerle bağlarsanız, aşağıdaki diyagramlarda olduğu gibi sürekli olarak sağa veya sola doğru giden ve asla yönü değiştirmeyen bir dalganın yolunu elde edersiniz.
2. Dalgalı Bir Kelime olabilir:
   • Birbirini izleyen her karakter bir öncekinin sağında (alfabesinde) bulunuyorsa yükseltme .
   • Birbirini izleyen her karakterin bir öncekinin solunda (alfabesinde) azalması.
3. Tüm eşit bağlantı kesilmiş, tüm tek bağlantılar yukarı olmalıdır.
4. Büyük / küçük harfleri yok sayabilir veya tümünü büyük harfe veya tümünü küçük harfe çevirebilir / dönüştürebilirsiniz.
5. Giriş sözcükleri yalnızca AZ alfabe aralığındaki karakterler, boşluk, noktalama işareti veya simge içermez.
6. Bir kelimenin "SPOON" gibi çift karakterleri varsa, çiftleri bir karaktere daraltmanız gerekir: "SPOON"> "SPON" (eğer O'dan O'ya giderseniz sıfır mesafedir).
7. Dalgalı Kelimeler (çiftler çöken sonra bile) en az 3 ayrı karakterleri içerecek.

İşte bazı örnekler:

Görev:

Standart girdiden bir sözcük alacak ve bir Dalgalı Sözcük ise veya çıkmayacak ve pozitif durumda, yükseliyor veya azalıyorsa çıktı alacak tam bir program veya işlev yazın . Çıkış olabilir True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, vb, bunu temsil etmek nasıl karar verirler.

Test senaryoları:

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

Kurallar:

• En kısa kod kazanır.

İsteğe Bağlı Görev:

Bir liste olarak , bir İngilizce sözlükte olabildiğince çok Dalgalı Kelime ve en uzununu bulun . Örneğin, İngilizce kelimelerin tam listesine buradan referans alabilirsiniz .

05AB1E , 11 9 bayt (Adnan'a teşekkürler)

Dg2›iÇü‹Ù

Çevrimiçi deneyin!

Dalgalı Kılıflar:

0 - Azalan Dalgalı

1 - Artan Dalgalı

Dalgalı Olmayan Kılıflar:

[0,1] - Dalgalı değil, başlangıçta azalıyor, ancak daha sonra paterni kıran bir artış / eşitlik var.

[1,0] - Dalgalı değil, başlangıçta artıyor, ancak daha sonra paterni bozan bir düşüş / eşitlik var

Giriş Dizesi - Uzunluk nedeniyle ilk etapta dalgalı olmak mümkün değildir.

Açıklama:

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.

Jöle , 10 bayt

OIṠḟ0µL’aQ

TryItOnline! veya tüm test senaryolarını çalıştırın

İade:
[1]artan dalgalı için
[-1]dalgalı azalan için
başka aksi bir şey ( [], [0], [-1,1], veya [1,-1])

(Gereksiz olarak beyan: her biri için tek bir değer için OIṠḟ0µL’aQS(11 bayt) döndürür 1, -1ve 0sırasıyla).

Nasıl?

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 bayt

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

Girişi karakter listesi olarak alır. Çıktılar:

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

Sıralanan giriş dizesinin orijinal veya tersine eşit olup olmadığını kontrol eder. Bunu 1 ve -1 adım boyutları ile dilimleyerek yapar. Aynı zamanda, kelimenin en az 2 ayrı harfi olup olmadığını kontrol ederiz.

"Hatalı çıkış" her iki durumda da bir çıktı kullanılamıyorsa, 51 bayta düşebiliriz:

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

Python 3, 77 75 bayt

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

Tüm harflerin aynı durumda olduğunu varsayar.

İadeler:

• 0 dalgalı değilse
• 1 eğer ileriye dalgalı ise
• 2 geriye dalgalı ise

@ETHproductions sayesinde gereksiz alanlar kaldırıldı

R, 96 95 bayt

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)

İadeler:

• 1 dalgalı ve yükseltmek için
• 2 dalgalı ve azaltmak için
• 3 dalgalı olmayanlar için

Açıklaması

• d=diff(rle(utf8ToInt(x))$v): dİlk önce dizeyi ASCIIdeğerlerine dönüştürerek utf8ToIntbir vektör oluşturur. Daha sonra kullanarak çalışma uzunluğu kodlaması gerçekleştirin rle. rle(...)$vdizinin yinelenmeyen değerlerini döndürür (yani tüm çalışmaların daraltılması). Sonunda farkı ele alalım.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Farklardan en az biri pozitif ve en az bir negatifse veya fark dizisi 2elemanlardan daha azsa (3 karakterden az orijinal kelimeye eşdeğer), kelime dalgalı değildir ve geri döner3
• else``if``(all(d<1),2,1): Tüm farklılıklar negatifse, 2dalgalı ve azalan geri dönüş , dalgalı ve kabarık geri dönüş 1.

R-fiddle'daki tüm test senaryolarını deneyin (test senaryoları için vektörleştirilebilecek şekilde adlandırıldığını unutmayın).

JavaScript (ES6), 84 81 bayt

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

Girişin hepsinin aynı durumda olduğunu varsayar. İade 1, dalgalı yetiştirmek için -1dalgalı azaltılmasında, 0veya -0dalgalı değil (her ikisi de falsy vardır). Düzenleme: @RobertHickman sayesinde 3 bayt kaydedildi.

Javascript (ES6), 84 80 78 bayt

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

Dalgalı artış 0 olduğunda, azalma 1'dir ve -1 dalgalı değildir.

Sayesinde @Neil Bana yardım ettiğin için 2 bayt kaydedin.

Pyth, 12 bayt

x*<2lrQ8_BQS

Çevrimiçi deneyin. Test odası.

Python 2, 53 52 50 bayt

Tırnak içine alınmış girdiyi bekler, örn. "watch"

İsimsiz lambda olarak:

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

Her harf arasındaki fark işaretini toplar ve tamsayı-böler len-1. Tüm olsaydı 1toplamıdır (artan), len-1görüntüler 1azaltılması için benzer -1ve karıştırılmaktadır 1, -1toplamından daha küçük olan len-1bu görüntüler, böylece 0.

Değiştirme -1 bayt cmp,s[1:],s[:-1])içincmp,s[1:],s)+1

Ruby, 54 bayt

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

0Sözcük dalgalı 1değilse, geriye doğru dalgalıysa ve 2ileri doğru dalgalıysa döndürür .

Groovy - 56 bayt

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

[1,0]Dalgalı yükseltme, dalgalı [0,1]azaltma, [0,0]tek karakter girişi veya [1,1]dalgalı olmayan çıkışlar .

NOT: Girdinin bir String veya char [] olduğunu ve tüm harflerin aynı durumda olduğunu varsayar.

PHP, 96 Bayt

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

veya 98 Bayt

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

0 dalgalı değil 1 yükseliyor -1 azalıyor

PHP, 100 bayt

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

İadeler:

• -1 dalgalı, azalan.
• 0 dalgalı değil.
• 1 dalgalı, yükseltmek için.

C, 164 bayt

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 değilse 0, wawy ve 1 ise 1, azalıyorsa 2 döndürür.

Raket 321 bayt

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

Ungolfed:

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

Test yapmak:

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

Çıktı:

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 bayt

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

Çıkışlar 0girdi dizesi, dalgalı değilse 1bir yetiştirme dalga ise ve 2bu bir azalan dalga buysa.

Test edilmemiş ve test kodu:

Burada deneyin.

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

Çıktı:

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