(Примітка. Це простіший розгін мого попереднього виклику « Знайти слова нескінченності!» , Який є спінінгом мого попереднього завдання « Знайти закручені слова! :)»

Визначення хвилястого слова :

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] - Не хвиляста, спочатку збільшується, але потім має зменшення / рівність, що порушило схему

Рядок введення - неможливо бути хвилястим в першу чергу через довжину.

Пояснення:

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

СпробуйтеItOnline! або запустити всі тестові приклади

Повертає:
[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. У той же час ми перевіряємо, чи слово має принаймні дві виразні літери.

Якщо "вихід з помилкою" може бути використаний вихід для жодного випадку, ми можемо опуститися до 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 95 байт

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-скрипці (зауважте, що він названий таким, що його можна векторизувати для тестових випадків).

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

Спробуйте в Інтернеті. Тестовий набір.

Пітон 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 = it [0]; c = [0] * 3; it.each {a-> c [(a <=> d)] = 1; d = a}; c [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, якщо не хвилястий, 1 якщо хвилеподібний і піднімається, 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)])))

Безумовно:

(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якщо це спадаюча хвиля.

Невикористаний і тестовий код:

Спробуйте тут.

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