(Nota: este es un spin-off más fácil de mi desafío anterior Find the Infinity Words!, Que es un spin-off de mi otro desafío anterior Find the Swirling Words! :))

Definición de una palabra ondulada :

1. Si conecta con curvas todos los caracteres de una Palabra ondulada en el alfabeto (AZ), obtiene el camino de una onda que va continuamente hacia la derecha o hacia la izquierda y nunca cambia de dirección, como en los diagramas a continuación.
2. Una palabra ondulada puede ser:
   • Aumento si cada carácter consecutivo está a la derecha (en el alfabeto) del anterior.
   • Disminuye si cada carácter consecutivo está a la izquierda (en el alfabeto) del anterior.
3. Toda la conexión par debe estar inactiva, todas las conexiones impares deben estar activadas.
4. Puede ignorar mayúsculas / minúsculas o considerar / convertir todo a mayúsculas o todo a minúsculas.
5. Las palabras de entrada son solo caracteres en el rango alfabético de AZ, sin espacios, sin signos de puntuación o símbolos.
6. Si una palabra tiene caracteres dobles, como "CUCHARA", debe contraer los dobles a un carácter: "CUCHARA"> "ESPONJA" (porque si va de O a O es distancia cero).
7. Las palabras onduladas contendrán al menos 3 caracteres distintos (incluso después del colapso de los dobles).

Aquí hay algunos ejemplos:

Tarea:

Escriba un programa o función completa que tomará una palabra de la entrada estándar y dará salida si es una palabra ondulada o no, y en caso positivo, dará salida si está aumentando o disminuyendo . La salida puede ser True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, etc, a decidir la forma de representar la misma.

Casos de prueba:

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

Reglas:

• El código más corto gana.

Tarea opcional:

Encuentre, en una lista, tantas palabras onduladas como pueda en un diccionario de inglés, y también las más largas. Puede tomar como referencia la lista completa de palabras en inglés aquí .

05AB1E , 11 9 bytes (Gracias a Adnan)

Dg2›iÇü‹Ù

Pruébalo en línea!

Casos ondulados:

0 - Ondulado decreciente

1 - Ondulado creciente

Casos no ondulados:

[0,1] - No ondulado, inicialmente disminuyendo, pero luego tiene un aumento / igualdad que rompió el patrón.

[1,0] - No ondulado, inicialmente aumentando, pero luego tiene una disminución / igualdad que rompió el patrón

Cadena de entrada : no es posible ser ondulado en primer lugar debido a la longitud.

Explicación:

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.

Jalea , 10 bytes

OIṠḟ0µL’aQ

TryItOnline! o ejecutar todos los casos de prueba

Devuelve:
[1]para aumentar ondulado
[-1]para disminuir ondulado
otra cosa de lo contrario ( [], [0], [-1,1], o [1,-1])

(Declarado como innecesaria: Para un único valor para cada uno OIṠḟ0µL’aQS(11 bytes) devolverá 1, -1y 0respectivamente).

¿Cómo?

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]

Toma la entrada como una lista de caracteres. Salidas:

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

Comprueba si la cadena de entrada ordenada es igual a su original o inversa. Lo hace cortando con pasos de 1 y -1. Al mismo tiempo, verificamos si la palabra tiene al menos 2 letras distintas.

Si se puede utilizar "salir con error" como salida para ninguno de los dos casos, podemos bajar a 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)

Asume que todas las letras son del mismo caso.

Devoluciones:

• 0 si no ondulado
• 1 si hacia adelante ondulado
• 2 si está ondulado hacia atrás

Se eliminaron espacios innecesarios gracias 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)

Devoluciones:

• 1 para ondulado y criado
• 2 para ondulado y decreciente
• 3 para no ondulado

Explicado

• d=diff(rle(utf8ToInt(x))$v): Genera una variable dconvirtiendo primero la cadena en sus ASCIIvalores usando lo utf8ToIntque convenientemente devuelve un vector. Posteriormente realice la codificación de longitud de ejecución usando rle. rle(...)$vdevuelve los valores no repetidos de la secuencia (es decir, contrayendo todas las ejecuciones). Finalmente toma la diferencia.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Si al menos una de las diferencias es positiva y al menos una negativa, o si la secuencia de diferencia tiene menos de 2elementos (equivalente a que la palabra original tenga menos de 3 caracteres), la palabra no es ondulada y regresa3
• else``if``(all(d<1),2,1): De lo contrario, si todas las diferencias son negativas, regrese 2para ondulado y decreciente, de lo contrario regrese 1para ondulado y subiendo.

Pruebe todos los casos de prueba en R-fiddle (tenga en cuenta que se llama de tal manera que se puede vectorizar para los casos de prueba).

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

Asume que la entrada está en el mismo caso. Retornos 1para aumentar ondulado, -1para disminuir ondulado 0o -0(ambos son falsos) para no ondulado. Editar: Guardado 3 bytes gracias a @RobertHickman.

Javascript (ES6), 84 80 78 bytes

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

Donde el aumento ondulado es 0, la disminución es 1 y -1 no es ondulado.

Gracias a @Neil por ayudarme a ahorrar 2 bytes.

Pyth, 12 bytes

x*<2lrQ8_BQS

Pruébalo en línea. Banco de pruebas.

Python 2, 53 52 50 bytes

Espera entradas entre comillas, por ejemplo "watch"

Como lambda sin nombre:

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

Suma el signo de diferencia entre cada letra y la división entera por len-1. Si todos estuvieran 1(aumentando), la suma len-1se muestra 1, similar para disminuir -1y para mezclar 1, -1la suma es menor de len-1lo que se muestra 0.

-1 byte para cambiar cmp,s[1:],s[:-1])acmp,s[1:],s)+1

Ruby, 54 bytes

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

Devuelve 0si la palabra no es ondulada, 1si es ondulada hacia atrás y 2si es ondulada hacia adelante.

Groovy - 56 bytes

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

Salidas [1,0]para elevar ondulado, [0,1]para disminuir ondulado, [0,0]para entrada de un solo carácter o [1,1]para no ondulado.

NOTA: Asume que la entrada es una Cadena o un carácter [] y todas las letras son del mismo 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);

o 98 bytes

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

0 no ondulado 1 subiendo -1 disminuyendo

PHP, 100 bytes

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

Devoluciones:

• -1 para ondulado, decreciente.
• 0 para no 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;}

Devuelve 0 si no está ondulado, 1 si está ondulado y subiendo, 2 si está disminuyendo.

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

Sin golf:

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

Pruebas:

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

Salida:

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

Emite 0si la cadena de entrada no es ondulada, 1si es una onda ascendente y 2si es una onda decreciente.

Ungolfed y código de prueba:

Pruébalo aquí

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

Salida:

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