(Uwaga: jest to łatwiejsze wydzielenie z mojego poprzedniego wyzwania Znajdź słowa nieskończoności ! , które jest spin-offem z mojego poprzedniego poprzedniego wyzwania Znajdź wirujące słowa! :))

Definicja falistego słowa :

1. Jeśli połączysz za pomocą krzywych wszystkie znaki falistego słowa z alfabetu (AZ), uzyskasz ścieżkę fali stale idącej w prawo lub w lewo i nigdy nie zmieniającej kierunku, jak na poniższych schematach.
2. Falista Słowo może być:
   • Podnoszenie, jeśli każdy kolejny znak znajduje się po prawej stronie (na alfabecie) od poprzedniego.
   • Zmniejsza się, jeśli każdy kolejny znak znajduje się po lewej stronie (na alfabecie) poprzedniego.
3. Wszystkie połączenia parzyste muszą być wyłączone, wszystkie połączenia nieparzyste muszą być uruchomione.
4. Możesz zignorować wielkie / małe litery lub rozważyć / przekonwertować wszystkie na wielkie lub wszystkie na małe.
5. Słowa wejściowe to tylko znaki z zakresu alfabetu AZ, bez spacji, interpunkcji i symboli.
6. Jeśli słowo ma podwójne znaki, takie jak „SPOON”, musisz zwinąć je do jednego znaku: „SPOON”> „SPON” (ponieważ jeśli przejdziesz od O do O, odległość wynosi zero).
7. W Faliste Słowa zawiera przynajmniej 3 różne postacie (nawet po podwójna zwijanie).

Oto kilka przykładów:

Zadanie:

Napisz pełny program lub funkcję, która weźmie słowo od standardowego wyjścia wejściowego i będzie, jeśli jest to Falista Słowo lub nie, aw przypadku pozytywnego, jeśli wyjście jest zwiększenie lub zmniejszenie . Wyjście może być True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, etc, ty decydujesz jak go reprezentować.

Przypadki testowe:

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

Zasady:

• Najkrótszy kod wygrywa.

Opcjonalne zadanie:

Znajdź w liście jak najwięcej falistych słów w słowniku angielskim, a także najdłuższy. Możesz wziąć przykładowo pełną listę angielskich słów tutaj .

05AB1E , 11 9 bajtów (Podziękowania dla Adnana)

Dg2›iÇü‹Ù

Wypróbuj online!

Faliste obudowy:

0 - malejąca falista

1 - Zwiększenie falistości

Nie faliste obudowy:

[0,1] - Nie falisty, początkowo malejący, ale potem ma wzrost / równość, która przerwała wzór.

[1,0] - Nie falisty, początkowo rosnący, ale potem ma spadek / równość, które złamały wzór

Ciąg wejściowy - nie można być falistym ze względu na długość.

Wyjaśnienie:

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.

Galaretka , 10 bajtów

OIṠḟ0µL’aQ

TryItOnline! lub uruchom wszystkie przypadki testowe

Powroty:
[1]dla falistych rosnącej
[-1]na malejącą falowane
coś jeszcze inaczej ( [], [0], [-1,1], lub [1,-1])

(Która została uznana za zbędną: Przez jedną wartość dla każdego OIṠḟ0µL’aQS(11 bajtów) powróci 1, -1i 0odpowiednio).

W jaki sposób?

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 bajty

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

Pobiera dane wejściowe jako listę znaków. Wyjścia:

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

Sprawdza, czy posortowany ciąg wejściowy jest równy jego oryginałowi czy odwrotności. Czyni to poprzez krojenie z krokami o wielkości 1 i -1. Jednocześnie sprawdzamy, czy słowo ma co najmniej 2 różne litery.

Jeśli „exit with error” może być użyte jako wyjście dla żadnego z tych przypadków, możemy przejść do 51 bajtów:

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

Python 3, 77 75 bajtów

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

Zakłada, że ​​wszystkie litery mają ten sam przypadek.

Zwroty:

• 0 jeśli nie falisty
• 1 jeśli przesuwa się falisty
• 2 jeśli jest pofalowany

Usunięto niepotrzebne spacje dzięki @ETHproductions

R 96 96 bajtów

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)

Zwroty:

• 1 za falowanie i podnoszenie
• 2 za faliste i malejące
• 3 dla niefalistych

Wyjaśniono

• d=diff(rle(utf8ToInt(x))$v): Generuje zmienną d, najpierw konwertując ciąg znaków na ASCIIwartości, za pomocą utf8ToIntktórych wygodnie zwraca wektor. Następnie wykonaj kodowanie długości przebiegu za pomocą rle. rle(...)$vzwraca niepowtarzalne wartości sekwencji (tj. zwijanie wszystkich przebiegów). Wreszcie weź różnicę.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Jeśli co najmniej jedna z różnic jest dodatnia, a co najmniej jedna ujemna, lub jeśli sekwencja różnic ma mniej niż 2elementy (odpowiednik oryginalnego słowa mającego mniej niż 3 znaki), słowo nie jest faliste i zwraca3
• else``if``(all(d<1),2,1): Inaczej, jeśli wszystkie różnice są ujemne, wróć 2do falistych i malejących, w przeciwnym razie wróć 1do falistych i przebijających.

Wypróbuj wszystkie przypadki testowe na stronie skrzypcach R (zwróć uwagę, że jest tak nazwany, że można go wektoryzować dla przypadków testowych).

JavaScript (ES6), 84 81 bajtów

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

Zakłada, że ​​dane wejściowe są w tym samym przypadku. Zwraca 1za podniesienie falistości, -1zmniejszenie falistości 0lub -0(oba są fałszem) za brak falowania. Edycja: Zapisano 3 bajty dzięki @RobertHickman.

JavaScript (ES6), 84 80 78 bajtów

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

Gdy faliste zwiększenie wynosi 0, zmniejszenie wynosi 1, a -1 nie jest faliste.

Dzięki @Neil za pomoc w oszczędzaniu 2 bajtów.

Pyth, 12 bajtów

x*<2lrQ8_BQS

Wypróbuj online. Zestaw testowy.

Python 2, 53 52 50 bajtów

Oczekuje danych wejściowych ujętych w cudzysłów, np "watch"

Jako nienazwana lambda:

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

Sumuje znak różnicy między każdą literą a liczbą całkowitą przez len-1. Jeśli wszystkie były 1(rosnące), suma jest len-1wyświetlana 1, podobnie w przypadku zmniejszania -1i mieszania 1, -1suma jest mniejsza niż w len-1takim przypadku0 .

-1 bajt do zmiany cmp,s[1:],s[:-1])nacmp,s[1:],s)+1

Rubinowy, 54 bajty

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

Zwraca, 0jeśli słowo nie jest faliste, 1jeśli jest faliste do tyłu i 2jeśli jest do przodu faliste.

Groovy - 56 bajtów

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

Dane wyjściowe [1,0]dla podnoszenia falistego, [0,1]zmniejszania falistego, [0,0]dla wprowadzania pojedynczych znaków lub[1,1] niefalowania.

UWAGA: Zakłada się, że dane wejściowe są ciągiem znaków lub znakiem [], a wszystkie litery mają ten sam przypadek.

PHP, 96 bajtów

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

lub 98 bajtów

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

0 nie falisty 1 podnoszenie -1 zmniejszanie

PHP, 100 bajtów

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

Zwroty:

• -1 za falisty, malejący.
• 0 za nie faliste.
• 1 za falowanie, podnoszenie.

C, 164 bajty

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

Zwraca 0, jeśli nie wawy, 1 jeśli wawy i przebijanie, 2 jeśli maleje.

Rakieta 321 bajtów

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

Nie golfowany:

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

Testowanie:

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

Wynik:

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 bajtów

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

Wywołuje, 0jeśli ciąg wejściowy nie jest falisty, 1jeśli jest falą podnoszącą, i2 jeśli jest to fala malejąca.

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wynik:

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