(Nota: questo è uno spin-off più semplice della mia precedente sfida Trova le parole infinite ! , che è uno spin-off della mia altra precedente sfida Trova le parole turbinanti! :))

Definizione di una parola ondulata :

1. Se si collegano con le curve tutti i caratteri di una parola ondulata sull'alfabeto (AZ), si ottiene il percorso di un'onda che va continuamente verso destra o verso sinistra e non cambia mai direzione, come negli schemi sotto.
2. Una parola ondulata può essere:
   • Sollevare se ogni carattere consecutivo si trova a destra (sull'alfabeto) di quello precedente.
   • Diminuendo se ogni carattere consecutivo si trova a sinistra (sull'alfabeto) di quello precedente.
3. Tutte le connessioni pari devono essere inattive, tutte le connessioni dispari devono essere attive.
4. È possibile ignorare le maiuscole / minuscole o considerare / convertire tutto in maiuscolo o tutto in minuscolo.
5. Le parole di input sono solo caratteri nell'intervallo alfabetico di AZ, nessuno spazio, nessuna punteggiatura o simboli.
6. Se una parola ha caratteri doppi, come "SPOON", devi comprimere i doppi in un carattere: "SPOON"> "SPON" (perché se passi da O a O è zero distanza).
7. Le parole ondulate conterranno almeno 3 caratteri distinti (anche dopo il collasso dei doppi).

Ecco alcuni esempi:

Compito:

Scrivi un programma o una funzione completi che prenderanno una parola dall'input standard e verranno emessi se si tratta di una parola ondulata o meno, e in caso positivo, l'output se sta aumentando o diminuendo . L'uscita può essere True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, ecc, si decide come rappresentare esso.

Casi test:

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

Regole:

• Il codice più corto vince.

Attività opzionale:

Trova, come elenco, quante più parole ondulate che puoi in un dizionario inglese e anche il più lungo. Puoi prendere ad esempio come riferimento l'elenco completo di parole inglesi qui .

05AB1E , 11 9 byte (Grazie ad Adnan)

Dg2›iÇü‹Ù

Provalo online!

Casi ondulati:

0 - Riduzione ondulata

1 - Aumentare ondulato

Casi non ondulati:

[0,1] - Non ondulato, inizialmente in diminuzione, ma poi ha un aumento / uguaglianza che ha rotto il modello.

[1,0] - Non ondulato, inizialmente in aumento, ma poi ha una diminuzione / uguaglianza che ha rotto il modello

Input String - Non è possibile essere ondulati in primo luogo a causa della lunghezza.

Spiegazione:

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.

Gelatina , 10 byte

OIṠḟ0µL’aQ

TryItOnline! o eseguire tutti i casi di test

Ritorni:
[1]per ondulato crescente
[-1]per ondulato diminuendo
qualcos'altro altrimenti ( [], [0], [-1,1], o [1,-1])

(Dichiarata come inutili: Per un singolo valore per ciascuno OIṠḟ0µL’aQS(11 byte) tornerà 1, -1e 0rispettivamente.)

Come?

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]

Accetta input come un elenco di caratteri. Uscite:

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

Verifica se la stringa di input ordinata è uguale al suo originale o al contrario. Lo fa affettando con passi di 1 e -1. Allo stesso tempo, controlliamo se la parola ha almeno 2 lettere distinte.

Se "exit with error" può essere usato come output per nessuno dei due casi, possiamo scendere a 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)

Presuppone che tutte le lettere siano dello stesso caso.

Ritorna:

• 0 se non ondulato
• 1 se in avanti ondulato
• 2 se ondulato all'indietro

Rimossi spazi non necessari grazie a @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)

Ritorna:

• 1 per ondulato e rilancio
• 2 per ondulato e decrescente
• 3 per non ondulato

spiegato

• d=diff(rle(utf8ToInt(x))$v): Genera una variabile dconvertendo prima la stringa nei suoi ASCIIvalori usando utf8ToIntquale restituisce comodamente un vettore. Successivamente eseguire la codifica della lunghezza della corsa utilizzando rle. rle(...)$vrestituisce i valori non ripetitivi della sequenza (ovvero comprimendo tutte le esecuzioni). Finalmente fai la differenza.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Se almeno una delle differenze è positiva e almeno una negativa, o se la sequenza di differenza ha meno di 2 elementi (equivalente alla parola originale con meno di 3 caratteri), la parola non è ondulata e restituisce3
• else``if``(all(d<1),2,1): Altrimenti se tutte le differenze sono negative, ritorna 2per ondulato e decrescente, altrimenti ritorna 1per ondulato e rilancio.

Prova tutti i casi di test su R-fiddle (nota che è chiamato in modo tale da poter essere vettorizzato per i casi di test).

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

Presuppone che l'input sia tutto nello stesso caso. Restituisce 1per aumentare ondulato, -1per diminuire ondulato 0o -0(entrambi sono falsi) per non ondulato. Modifica: salvato 3 byte grazie a @RobertHickman.

Javascript (ES6), 84 80 78 byte

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

Dove l'aumento ondulato è 0, la diminuzione è 1 e -1 non è ondulato.

Grazie a @Neil per avermi aiutato a salvare 2 byte.

Pyth, 12 byte

x*<2lrQ8_BQS

Provalo online. Suite di test.

Python 2, 53 52 50 byte

Prevede input racchiusi tra virgolette, ad es "watch"

Come lambda senza nome:

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

Somma il segno di differenza tra ogni lettera e numero intero diviso per len-1. Se tutti 1(aumentando) la somma è len-1visualizzata 1, simile per diminuzione -1e per misto 1, -1la somma è minore dilen-1 così viene visualizzata 0.

-1 byte per passare cmp,s[1:],s[:-1])acmp,s[1:],s)+1

Rubino, 54 byte

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

Restituisce 0se la parola non è ondulata, 1se è ondulata all'indietro e 2se è ondulata in avanti.

Groovy - 56 byte

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

Uscite [1,0]per l'innalzamento ondulato, [0,1]per l'ondulazione decrescente, [0,0]per l'immissione di singoli caratteri o [1,1]per non ondulati.

NOTA: si suppone che l'input sia una stringa o un carattere [] e che tutte le lettere siano dello stesso caso.

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

o 98 byte

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

0 non ondulato 1 in aumento -1 in diminuzione

PHP, 100 byte

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

Ritorna:

• -1 per ondulato, decrescente.
• 0 per non ondulato.
• 1 per ondulato, alzando.

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

Restituisce 0 se non pazzo, 1 se pazzo e in aumento, 2 se decrescente.

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

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:

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

Produzione:

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

Emette 0se la stringa di input non è ondulata, 1se è un'onda che si alza e2 se è un'onda decrescente.

Codice non testato e test:

Provalo qui.

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

Produzione:

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