(Nota: este é um spin-off mais fácil do meu desafio anterior Find the Infinity Words!, Que é um spin-off do meu outro desafio anterior Find the Swirling Words! :))

Definição de uma palavra ondulada :

1. Se você conectar com curvas todos os caracteres de uma Palavra Ondulada no alfabeto (AZ), obterá o caminho de uma onda indo continuamente para a direita ou para a esquerda e nunca mudando de direção, como nos diagramas abaixo.
2. Uma palavra ondulada pode ser:
   • Aumentando se cada caractere consecutivo está à direita (no alfabeto) do anterior.
   • Diminuindo se cada caractere consecutivo estiver à esquerda (no alfabeto) do caractere anterior.
3. Todas as conexões pares devem estar inoperantes, todas as conexões ímpares devem estar ativadas.
4. Você pode ignorar maiúsculas / minúsculas ou considerar / converter tudo em maiúsculas ou tudo em minúsculas.
5. As palavras de entrada são apenas caracteres no intervalo alfabético de AZ, sem espaços, sem pontuação ou símbolos.
6. Se uma palavra tiver caracteres duplos, como "COLHER", você deverá reduzir as dobras para um caractere: "COLHER"> "COLHER" (porque se você passar de O para O é a distância zero).
7. As Palavras Onduladas conterão pelo menos 3 caracteres distintos (mesmo após o colapso das duplas).

Aqui estão alguns exemplos:

Tarefa:

Escreva um programa ou função completa que retire uma palavra da entrada padrão e saia se for uma Palavra Ondulada ou não, e, no caso positivo, saia se estiver aumentando ou diminuindo . A saída pode ser True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, etc, você decide como para representá-lo.

Casos de teste:

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

Regras:

• O menor código vence.

Tarefa opcional:

Encontre, como uma lista, o maior número possível de Palavras Onduladas em um dicionário em inglês, e as mais longas também. Você pode tomar, por exemplo, como referência a lista completa de palavras em inglês aqui .

05AB1E , 11 9 bytes (Graças a Adnan)

Dg2›iÇü‹Ù

Experimente online!

Casos ondulados:

0 - Diminuindo Ondulado

1 - Aumentando Ondulado

Casos não ondulados:

[0,1] - Não ondulado, diminuindo inicialmente, mas depois apresenta um aumento / igualdade que quebrou o padrão.

[1,0] - Não ondulado, aumentando inicialmente, mas depois apresenta uma diminuição / igualdade que quebrou o padrão

String de entrada - Não é possível ficar ondulado em primeiro lugar devido ao comprimento.

Explicação:

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 bytes

OIṠḟ0µL’aQ

TryItOnline! ou execute todos os casos de teste

Returns:
[1]para ondulado aumentando
[-1]para ondulado diminuindo
outra coisa de outra forma ( [], [0], [-1,1]ou [1,-1])

(Declarada como desnecessária: Para um único valor para cada um OIṠḟ0µL’aQS(11 bytes) voltará 1, -1e 0respectivamente).

Quão?

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 bytes

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

Recebe a entrada como uma lista de caracteres. Saídas:

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

Verifica se a sequência de entrada classificada é igual ao original ou reversa. Faz isso cortando com tamanhos de etapas de 1 e -1. Ao mesmo tempo, verificamos se a palavra tem pelo menos 2 letras distintas.

Se "exit with error" puder ser usado como saída nos dois casos, podemos reduzir para 51 bytes:

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

Python 3, 77 75 bytes

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

Assume que todas as letras são do mesmo caso.

Devoluções:

• 0 se não for ondulado
• 1 se encaminha ondulado
• 2 se ondulado para trás

Removidos espaços desnecessários graças a @ETHproductions

R, 96 95 bytes

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)

Devoluções:

• 1 para ondulado e levantando
• 2 para ondulado e decrescente
• 3 para não ondulado

Explicado

• d=diff(rle(utf8ToInt(x))$v): Gera uma variável dconvertendo primeiro a cadeia de caracteres em seus ASCIIvalores usando o utf8ToIntque convenientemente retorna um vetor. Posteriormente, execute a codificação do comprimento da execução usando rle. rle(...)$vretorna os valores não repetidos da sequência (ou seja, recolhendo todas as execuções). Finalmente pegue a diferença.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Se pelo menos uma das diferenças for positiva e pelo menos uma negativa, ou se a sequência de diferenças tiver menos de 2elementos (equivalente à palavra original com menos de 3 caracteres), a palavra não será ondulada e retornará3
• else``if``(all(d<1),2,1): Caso contrário, se todas as diferenças forem negativas, retorne 2 contrário, para ondulado e decrescente; caso contrário, retorne 1para ondulado e aumentado.

Experimente todos os casos de teste no R-fiddle (observe que o nome é tal que pode ser vetorizado para os casos de teste).

JavaScript (ES6), 84 81 bytes

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

Assume que a entrada é tudo no mesmo caso. Retorna 1para aumentar ondulado, -1para diminuir ondulado 0ou -0(ambos são falsos) para não ondulado. Editar: salvou 3 bytes graças a @RobertHickman.

Javascript (ES6), 84 80 78 bytes

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

Onde o aumento ondulado é 0, o decréscimo é 1 e -1 não é ondulado.

Agradeço ao @ Neil por me ajudar a economizar 2 bytes.

Pitão, 12 bytes

x*<2lrQ8_BQS

Experimente online. Suíte de teste.

Python 2, 53 52 50 bytes

Espera a entrada entre aspas, por exemplo "watch"

Como lambda sem nome:

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

Soma o sinal de diferença entre cada letra e o número inteiro dividido por len-1. Se todos estivessem 1(aumentando) a soma que é len-1exibida 1, semelhante para diminuir -1e para misto 1, -1a soma é menor do que len-1é exibida 0.

-1 byte para mudar cmp,s[1:],s[:-1])paracmp,s[1:],s)+1

Ruby, 54 bytes

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

Retorna 0se a palavra não estiver ondulada, 1se estiver ondulada para trás e 2se estiver ondulada para frente.

Groovy - 56 bytes

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

Saídas [1,0]para aumentar ondulado, [0,1]para diminuir ondulado, [0,0]para entrada de caractere único ou [1,1]para não ondulado.

NOTA: Assume que a entrada é uma String ou um caractere [] e todas as letras são do mesmo caso.

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

ou 98 bytes

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

0 não ondulado 1 aumentando -1 diminuindo

PHP, 100 bytes

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

Devoluções:

• -1 para ondulado, diminuindo.
• 0 para não ondulado.
• 1 para ondulado, levantando.

C, 164 bytes

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

Retorna 0 se não estiver em movimento, 1 se estiver em movimento e aumentando, 2 se estiver diminuindo.

Raquete 321 bytes

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

Teste:

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

Resultado:

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 bytes

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

Saída 0se a sequência de entrada não estiver ondulada, 1se for uma onda crescente e 2se for uma onda decrescente.

Ungolfed & código de teste:

Experimente aqui.

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

Resultado:

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