(Hinweis: Dies ist eine einfachere Abwandlung meiner vorherigen Herausforderung " Find the Infinity Words!" , Die eine Abwandlung meiner anderen vorherigen Herausforderung " Find the Swirling Words!" Ist. :))

Definition eines welligen Wortes :

1. Wenn Sie alle Zeichen eines Wellenworts auf dem Alphabet (AZ) mit Kurven verbinden , erhalten Sie den Pfad einer Welle, die kontinuierlich nach rechts oder links verläuft und die Richtung nie ändert, wie in den folgenden Diagrammen.
2. Ein welliges Wort kann sein:
   • Wird ausgelöst, wenn sich jedes aufeinanderfolgende Zeichen rechts (im Alphabet) vom vorherigen befindet.
   • Absteigend, wenn sich jedes aufeinanderfolgende Zeichen links (im Alphabet) des vorherigen befindet.
3. Alle geraden Verbindungen müssen unterbrochen sein, alle ungeraden Verbindungen müssen aktiviert sein.
4. Sie können Groß- / Kleinschreibung ignorieren oder alle in Groß- oder Kleinschreibung umwandeln.
5. Die eingegebenen Wörter sind nur Zeichen im alphabetischen Bereich von AZ, keine Leerzeichen, keine Interpunktion oder Symbole.
6. Wenn ein Wort doppelte Zeichen wie "SPOON" enthält, müssen Sie die doppelten Zeichen zu einem Zeichen zusammenfassen: "SPOON"> "SPON" (denn wenn Sie von O nach O gehen, ist der Abstand Null).
7. Die wellenförmigen Wörter enthalten mindestens 3 verschiedene Zeichen (auch nach dem Zusammenfallen von Doppelzeichen).

Hier einige Beispiele:

Aufgabe:

Schreiben Sie ein vollständiges Programm oder eine Funktion, die ein Wort von der Standardeingabe übernimmt und ausgibt, ob es sich um ein Wellenwort handelt oder nicht, und im positiven Fall, wenn es angehoben oder abgesenkt wird . Der Ausgang kann sein True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, usw, entscheiden Sie , wie es zu vertreten.

Testfälle:

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

Regeln:

• Kürzester Code gewinnt.

Optionale Aufgabe:

Finden Sie als Liste so viele wellenförmige Wörter wie möglich in einem englischen Wörterbuch und die längste. Sie können die vollständige Liste der englischen Wörter zum Beispiel als Referenz nehmen hier .

05AB1E , 11 9 Bytes (Dank an Adnan)

Dg2›iÇü‹Ù

Probieren Sie es online!

Wellenförmige Fälle:

0 - Abnehmende Welligkeit

1 - Zunehmende Welligkeit

Nicht gewellte Fälle:

[0,1] - Nicht wellig, anfänglich abnehmend, aber dann mit einer Zunahme / Gleichheit, die das Muster durchbrochen hat.

[1,0] - Nicht wellig, anfänglich ansteigend, aber dann mit einer Abnahme / Gleichheit, die das Muster durchbrochen hat

Input String - Wegen der Länge ist es nicht möglich, gewellt zu sein.

Erläuterung:

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.

Gelee , 10 Bytes

OIṠḟ0µL’aQ

TryItOnline! oder führen Sie alle Testfälle aus

Rückkehr:
[1]für wellige Erhöhung
[-1]für wellige abnehmend
etwas anderes sonst ( [], [0], [-1,1], oder [1,-1])

(Angegeben als unnötig: Für einen einzelnen Wert für jedes OIṠḟ0µL’aQS(11 Bytes) zurückkehren 1, -1und 0jeweils) .

Wie?

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]

Übernimmt die Eingabe als Liste von Zeichen. Ausgänge:

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

Überprüft, ob die sortierte Eingabezeichenfolge der ursprünglichen oder der umgekehrten entspricht. Dazu schneiden Sie mit den Schrittgrößen 1 und -1. Gleichzeitig prüfen wir, ob das Wort mindestens zwei verschiedene Buchstaben hat.

Wenn "exit with error" für keinen der beiden Fälle als Ausgabe verwendet werden kann, können wir auf 51 Bytes zurückgehen:

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)

Angenommen, alle Buchstaben sind gleich.

Kehrt zurück:

• 0 wenn nicht wellig
• 1 wenn vorwärts wellig
• 2 wenn rückwärts gewellt

Überflüssige Leerzeichen wurden dank @ETHproductions entfernt

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)

Kehrt zurück:

• 1 für wellig und heben
• 2 für wellig und abnehmend
• 3 für nicht wellig

Erklärt

• d=diff(rle(utf8ToInt(x))$v): Erzeugt eine Variable, dindem zuerst die Zeichenfolge in ihre ASCIIWerte konvertiert wird , wobei utf8ToIntzweckmäßigerweise ein Vektor zurückgegeben wird. Führen Sie anschließend die Lauflängencodierung mit aus rle.rle(...)$vGibt die sich nicht wiederholenden Werte der Sequenz zurück (dh alle Läufe werden ausgeblendet). Nimm endlich den Unterschied.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Wenn mindestens eine der Differenzen positiv und mindestens eine negativ ist oder wenn die Differenzsequenz kleiner als ist 2 Elemente enthält (entspricht dem ursprünglichen Wort mit weniger als 3 Zeichen), ist das Wort nicht wellig und kehrt zurück3
• else``if``(all(d<1),2,1): Andernfalls, wenn alle Unterschiede negativ sind, kehren Sie 2für wellig und abnehmend zurück, andernfalls kehren Sie 1für wellig und steigend zurück .

Probieren Sie alle Testfälle bei R-fiddle aus (beachten Sie, dass der Name so lautet, dass er für die Testfälle vektorisiert werden kann).

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

Angenommen, die Eingabe ist alle in demselben Fall. Gibt 1für das Erhöhen der Wellenlänge , -1für das Verringern der Wellenlänge 0oder -0(beide sind falsch) für das Nicht-Wellenförmig zurück. Bearbeiten: 3 Bytes dank @RobertHickman gespeichert.

Javascript (ES6), 84 80 78 Bytes

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

Wenn die Wellenzunahme 0 ist, ist die Abnahme 1 und -1 ist nicht wellig.

Vielen Dank an @Neil, der mir geholfen hat, 2 Bytes zu sparen.

Pyth, 12 Bytes

x*<2lrQ8_BQS

Probieren Sie es online aus. Testsuite.

Python 2, 53 52 50 Bytes

Erwartet in Anführungszeichen eingeschlossene Eingaben, z "watch"

Als unbenanntes Lambda:

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

Summiert das Vorzeichen der Differenz zwischen den einzelnen Buchstaben und die Ganzzahl dividiert durch len-1. Wenn alle 1(aufsteigend) sind, wird die Summe len-1angezeigt 1, ähnlich wie bei abnehmenden -1und gemischten Werten 1. -1Die Summe ist kleiner als die Summe , die len-1angezeigt wird0 .

-1 Byte für den Wechsel cmp,s[1:],s[:-1])zucmp,s[1:],s)+1

Ruby, 54 Bytes

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

Gibt zurück, 0wenn das Wort nicht wellig ist.1 wenn es rückwärts wellig ist und 2wenn es vorwärts wellig ist.

Groovy - 56 Bytes

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

Ausgänge [1,0]zum Erhöhen der Wellenlänge, [0,1]zum Verringern der Wellenlänge, [0,0]zur Eingabe einzelner Zeichen oder[1,1] für Nicht-Wellenformen.

HINWEIS: Es wird davon ausgegangen, dass die Eingabe entweder ein String oder ein Zeichen [] ist und alle Buchstaben den gleichen Groß- / Kleinschreibungstyp haben.

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

oder 98 Bytes

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

0 nicht wellig 1 ansteigend -1 absteigend

PHP, 100 Bytes

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

Kehrt zurück:

• -1 für wellig, abnehmend.
• 0 für nicht wellig.
• 1 für wellig, erhöhen.

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

Gibt 0 zurück, wenn es nicht wawy ist, 1, wenn es wawy ist und erhöht, 2, wenn es abnimmt.

Schläger 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)]
      )))

Testen:

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

Ausgabe:

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

Gibt aus, 0wenn die Eingabezeichenfolge nicht wellig ist, 1wenn es sich um eine ansteigende Welle handelt, und2 wenn es sich um eine absteigende Welle handelt.

Ungolfed & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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