(Примечание: это более легкое выделение из моего предыдущего задания « Найди слова бесконечности!» , Которое является ответвлением от моего другого предыдущего задания « Найти закрученные слова!» :))

Определение волнистого слова :

1. Если вы соедините кривыми все символы Волнистого Слова в алфавите (AZ), вы получите путь волны, непрерывно идущей вправо или влево и никогда не меняющей направления, как на рисунках ниже.
2. Волнистые Слово может быть:
   • Повышение, если каждый последующий символ находится справа (по алфавиту) от предыдущего.
   • Уменьшение, если каждый последующий символ находится слева (на алфавите) от предыдущего.
3. Все четные соединения должны быть отключены, все нечетные соединения должны быть отключены.
4. Вы можете игнорировать верхний / нижний регистр или рассматривать / конвертировать все в верхний регистр или все в нижний регистр.
5. Вводимые слова - это только символы в диапазоне алфавита AZ, без пробелов, знаков пунктуации или символов.
6. Если слово содержит двойные символы, такие как «SPOON», вы должны свернуть двойные символы до одного символа: «SPOON»> «SPON» (потому что при переходе от O к O это нулевое расстояние).
7. В Слова Волнистые будет содержать , по крайней мере , 3 различных символов (даже после того, как двойники коллапса).

Вот несколько примеров:

Задача:

Напишите полную программу или функцию, которая будет принимать слово из стандартного ввода и выводить, если оно является волнистым или нет, и в положительном случае выводить, если оно увеличивается или уменьшается . Выход может быть True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WDи т.д., вы решаете , как представить его.

Тестовые случаи:

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

Правила:

• Самый короткий код выигрывает.

Необязательная задача:

Найдите в списке как можно больше волнистых слов в английском словаре, а также самое длинное. Вы можете взять, например, в качестве ссылки полный список английских слов здесь .

05AB1E , 11 9 байт (спасибо Аднану )

Dg2›iÇü‹Ù

Попробуйте онлайн!

Волнистые чехлы:

0 - Уменьшение волнистости

1 - Увеличение волнистости

Не волнистые случаи:

[0,1] - Не волнистая, изначально уменьшающаяся, но затем имеет увеличение / равенство, которое нарушает шаблон.

[1,0] - Не волнистый, изначально растущий, но затем имеет уменьшение / равенство, которое нарушает модель

Input String - Невозможно быть волнистым в первую очередь из-за длины.

Объяснение:

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.

Желе , 10 байт

OIṠḟ0µL’aQ

TryItOnline! или запустите все тесты

Возвращает:
[1]для волнистого увеличения
[-1]для волнистого уменьшающегося
что - то другого в противном случае ( [], [0], [-1,1]или [1,-1])

(Заявлен как ненужное: для одного значения для каждого OIṠḟ0µL’aQS(11 байт) будет возвращать 1, -1и 0соответственно.)

Как?

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 байта

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

Вводит в виде списка символов. Выходы:

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

Проверяет, равна ли отсортированная входная строка ее оригиналу или наоборот. Делает это путем нарезки с шагом 1 и -1. В то же время мы проверяем, имеет ли слово хотя бы 2 разные буквы.

Если «выход с ошибкой» может быть использован для вывода ни в одном из случаев, мы можем уменьшить значение до 51 байта:

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

Python 3, 77 75 байт

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

Предполагается, что все буквы одного и того же случая.

Возвращает:

• 0 если не волнистый
• 1 если вперед волнистые
• 2 если назад волнистые

Удалил ненужные пробелы благодаря @ETHproductions

R 96 96 байт

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)

Возвращает:

• 1 для волнистых и поднятия
• 2 для волнистых и убывающих
• 3 для не волнистых

Разъяснения

• d=diff(rle(utf8ToInt(x))$v): Генерирует переменную d, сначала преобразовывая строку в ее ASCIIзначения, используя utf8ToIntкоторые удобно возвращает вектор. Затем выполните кодирование длины серии, используя rle. rle(...)$vвозвращает неповторяющиеся значения последовательности (т. е. сворачивание всех прогонов). Наконец-то возьми разницу.
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: Если хотя бы одно из различий положительное и хотя бы одно отрицательное или если последовательность различий имеет меньше 2элементов (эквивалентно исходному слову, содержащему менее 3 символов), слово не является волнистым и возвращает3
• else``if``(all(d<1),2,1)Иначе, если все различия отрицательны, возврат 2к волнистости и уменьшению, иначе возврат 1к волнистости и повышению.

Попробуйте все тестовые случаи в R-fiddle (обратите внимание, что он назван так, что он может быть векторизован для тестовых случаев).

JavaScript (ES6), 84 81 байт

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

Предполагается, что ввод все в том же случае. Возвращает 1для повышения волнистости, -1для уменьшения волнистости, 0или -0(оба ложные) для не волнистости. Изменить: Сохранено 3 байта благодаря @RobertHickman.

Javascript (ES6), 84 80 78 байт

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

Там, где волнистое увеличение равно 0, уменьшение равно 1, а -1 не является волнистым.

Спасибо @Neil за помощь в экономии 2 байтов.

Pyth, 12 байт

x*<2lrQ8_BQS

Попробуйте онлайн. Тестирование.

Python 2, 53 52 50 байт

Ожидается ввод в кавычках, например "watch"

Как неназванная лямбда:

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

Суммирует знак различия между буквами и делит их на целое число len-1. Если бы все были 1(увеличивались), то сумма, которую len-1она отображает 1, аналогична для уменьшения -1и для смешанного 1, -1сумма меньше, чем len-1она отображает 0.

-1 байт для перехода cmp,s[1:],s[:-1])наcmp,s[1:],s)+1

Рубин, 54 байта

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

Возвращает, 0если слово не волнистое, 1если назад волнистое, и 2если вперед волнистое.

Groovy - 56 байт

{D = это [0]; с = [0] * 3; it.each {а-> с [(а <=> г)] = 1; г = а}; с [1 ..- 1]}

Выходы [1,0]для увеличения волнистости, [0,1]для уменьшения волнистости, [0,0]для односимвольного ввода или [1,1]для не волнистых.

ПРИМЕЧАНИЕ. Предполагается, что вводом является либо строка, либо символ [], и все буквы имеют одинаковый регистр.

PHP, 96 байт

for(;($t=$argv[1])[++$i];)$s+=$r[]=$t[$i-1]<=>$t[$i];echo(max($r)-min($r)<2)*(0<=>$s)*(1<$s*$s);

или 98 байт

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

0 не волнистый 1 повышение -1 уменьшение

PHP, 100 байт

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

Возвращает:

• -1 для волнистых, уменьшается.
• 0 для не волнистых.
• 1 для волнистых, поднимая.

C 164 байта

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

Возвращает 0, если не wawy, 1, если wawy и повышение, 2, если уменьшается.

Ракетка 321 байт

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

Тестирование:

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

Выход:

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 байт

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

Выводится, 0если входная строка не волнистая, 1если это восходящая волна и 2если это убывающая волна.

Ungolfed & тестовый код:

Попробуй это здесь.

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

Выход:

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