(Remarque: il s'agit d'un spin-off plus facile de mon défi précédent Find the Infinity Words!, Qui est un spin-off de mon autre défi précédent Find the Swirling Words! :))

Définition d'un mot ondulé :

1. Si vous connectez avec des courbes tous les caractères d'un mot ondulé sur l'alphabet (AZ), vous obtenez le chemin d'une onde allant continuellement vers la droite ou vers la gauche et ne changeant jamais de direction, comme dans les schémas ci-dessous.
2. Un mot ondulé peut être:
   • Augmenter si chaque caractère consécutif est à droite (sur l'alphabet) du précédent.
   • Diminue si chaque caractère consécutif est à gauche (sur l'alphabet) du précédent.
3. Toutes les connexions paires doivent être interrompues, toutes les connexions impaires doivent être actives.
4. Vous pouvez ignorer les majuscules / minuscules ou considérer / convertir tout en majuscules ou tout en minuscules.
5. Les mots saisis sont uniquement des caractères de la gamme alphabétique AZ, pas d'espaces, pas de ponctuation ou des symboles.
6. Si un mot a des caractères doubles, comme "SPOON", vous devez réduire les doubles à un caractère: "SPOON"> "SPON" (car si vous passez de O à O, la distance est nulle).
7. Les mots ondulés contiendront au moins 3 caractères distincts (même après l'effondrement des doubles).

Voici quelques exemples:

Tâche:

Écrire un programme complet ou une fonction qui prendra un mot d'entrée et la sortie standard volonté si elle est un mot onduleux ou non, et dans le cas positif, la production si elle soulève ou baisse . La sortie peut être True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, etc, vous décidez comment représenter.

Cas de 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

Règles:

• Le code le plus court gagne.

Tâche facultative:

Trouvez, sous forme de liste, autant de mots ondulés que possible dans un dictionnaire anglais, et le plus long aussi. Vous pouvez prendre par exemple comme référence la liste complète des mots anglais ici .

05AB1E , 11 9 octets (Merci à Adnan)

Dg2›iÇü‹Ù

Essayez-le en ligne!

Cas ondulés:

0 - Diminution ondulée

1 - Augmentation de l'ondulation

Cas non ondulés:

[0,1] - Pas ondulé, initialement décroissant, mais a ensuite une augmentation / égalité qui a brisé le motif.

[1,0] - Pas ondulé, initialement en augmentation, mais a ensuite une diminution / égalité qui a brisé le motif

Chaîne d'entrée - Impossible d'être ondulé en premier lieu en raison de la longueur.

Explication:

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.

Gelée , 10 octets

OIṠḟ0µL’aQ

TryItOnline! ou exécutez tous les cas de test

Renvoie:
[1]pour les cheveux ondulés de plus en plus
[-1]pour les cheveux ondulés diminuant
autre chose autrement ( [], [0], [-1,1]ou [1,-1])

(Déclarée comme inutile: Pour obtenir une valeur unique pour chaque OIṠḟ0µL’aQS(11 octets) retourne 1, -1et 0respectivement).

Comment?

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 octets

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

Prend la saisie sous forme de liste de caractères. Les sorties:

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

Vérifie si la chaîne d'entrée triée est égale à son origine ou son inverse. Le fait en découpant avec des tailles de pas de 1 et -1. Dans le même temps, nous vérifions si le mot a au moins 2 lettres distinctes.

Si "exit with error" peut être utilisé comme sortie pour les deux cas, on peut descendre à 51 octets:

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

Python 3, 77 75 octets

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

Suppose que toutes les lettres sont du même cas.

Retour:

• 0 sinon ondulé
• 1 si en avant ondulé
• 2 si ondulé en arrière

Suppression des espaces inutiles grâce à @ETHproductions

R, 96 95 octets

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)

Retour:

• 1 pour onduler et soulever
• 2 pour ondulé et décroissant
• 3 pour non ondulé

Expliqué

• d=diff(rle(utf8ToInt(x))$v): Génère une variable den convertissant d'abord la chaîne en ses ASCIIvaleurs en utilisant utf8ToIntce qui renvoie commodément un vecteur. Exécutez ensuite l'encodage de la longueur d'exécution à l'aide de rle.rle(...)$vrenvoie les valeurs non répétitives de la séquence (c'est-à-dire en réduisant toutes les exécutions). Prenez enfin la différence.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Si au moins une des différences est positive et au moins une négative, ou si la séquence de différence a moins de 2éléments (équivalent au mot d'origine ayant moins de 3 caractères), le mot est non ondulé et retourne3
• else``if``(all(d<1),2,1): Sinon si toutes les différences sont négatives, retour 2pour ondulé et décroissant, sinon retour 1pour ondulé et élévation.

Essayez tous les cas de test chez R-fiddle (notez qu'il est nommé de manière à pouvoir être vectorisé pour les cas de test).

JavaScript (ES6), 84 81 octets

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

Suppose que l'entrée est tout dans le même cas. Renvoie 1pour augmenter ondulé, -1pour diminuer ondulé 0ou -0(les deux sont faux) pour non ondulé. Edit: sauvé 3 octets grâce à @RobertHickman.

Javascript (ES6), 84 80 78 octets

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

Où l'augmentation ondulée est 0, la diminution est 1 et -1 n'est pas ondulé.

Grâce à @Neil de m'avoir aidé à économiser 2 octets.

Pyth, 12 octets

x*<2lrQ8_BQS

Essayez-le en ligne. Suite de tests.

Python 2, 53 52 50 octets

Attend une entrée entre guillemets, par exemple "watch"

En tant que lambda sans nom:

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

Additionne le signe de différence entre chaque lettre et divise l'entier par len-1. Si tous étaient 1(augmentant), la somme est len-1affichée 1, similaire pour décroissante -1et pour mixte 1, -1la somme est inférieure à len-1ce qu'elle affiche 0.

-1 octet pour passer cmp,s[1:],s[:-1])àcmp,s[1:],s)+1

Rubis, 54 octets

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

Retour 0 si le mot n'est pas ondulé, 1s'il est ondulé vers l'arrière et 2s'il est ondulé vers l'avant.

Groovy - 56 octets

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

Sorties [1,0]pour augmenter ondulé, [0,1]pour diminuer ondulé, [0,0]pour entrée de caractère unique ou [1,1]pour non ondulé.

REMARQUE: suppose que l'entrée est une chaîne ou un caractère [] et toutes les lettres sont du même cas.

PHP, 96 octets

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 octets

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

0 non ondulé 1 augmentant -1 diminuant

PHP, 100 octets

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

Retour:

• -1 pour ondulé, décroissant.
• 0 pour pas ondulé.
• 1 pour ondulé, soulevant.

C, 164 octets

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

Renvoie 0 si pas wawy, 1 si wawy et augmente, 2 si diminue.

Raquette 321 octets

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

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

Essai:

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

Production:

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 octets

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

Sort 0si la chaîne d'entrée n'est pas ondulée, 1si c'est une onde montante et 2si c'est une onde décroissante.

Code non testé et testé:

Essayez-le ici.

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

Production:

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