(Примітка. Це спінінг мого попереднього виклику Знайти закручені слова! )

Визначення слова нескінченності :

1. Якщо ви з'єднаєте кривими всі символи слова нескінченності в алфавіті (AZ), ви отримаєте символ нескінченності ∞, як на діаграмах нижче.
2. Всі парні з'єднання повинні бути відключені , всі непарні з'єднання повинні бути вгору .
3. Ви можете проігнорувати верхній / нижній регістр або розглянути / перетворити всі у великі регістри або всі в малі регістри.
4. Введені слова - це лише символи в алфавітному діапазоні AZ, без пробілів, без розділових знаків чи символів.
5. Кожне слово має містити рівно 5 символів. Слова> 5 або <5 недійсні.
6. Якщо слово має подвійні послідовні символи, це слово недійсне, як-от "FLOOD" або "QUEEN".
7. Усі слова нескінченності починаються і закінчуються одним і тим же символом.

Ось кілька прикладів:

Завдання:

Напишіть повну програму або функцію, яка візьме слово зі стандартного введення і виведе, якщо це слово нескінченності чи ні. Вихід може бути істинним / хибним, 1/0, 1 / Null тощо.

Тестові приклади:

Infinity Words:
ALPHA, EAGLE, HARSH, NINON, PINUP, RULER, THEFT, WIDOW

NOT Infinity Words:
CUBIC, ERASE, FLUFF, LABEL, MODEM, RADAR, RIVER, SWISS, TRUST, 
KNEES, QUEEN, GROOVE, ONLY, CHARACTER, OFF, IT, ORTHO

Правила:

1. Найкоротший код виграє.

Необов’язкове завдання:

Знайдіть у списку стільки слів нескінченності, скільки ви можете в словнику англійської мови. Ви можете взяти для прикладу повний список англійських слів тут .

Желе , 43 41 40 25 24 23 22 21 14 13 байт

-7 байт завдяки fireflame241 ( 0ị=1ị$-> =ṚḢта використанню IIA⁼2,2для тестування на 4 обертання)

-1 Завдяки Кевіну Кройссену (використання раніше недоступного салату, Ø2який дає урожай [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
Або всі тестові випадки (плюс "ПРАВИЛА")

Як?

Слово нескінченності має:

1. однаковий перший і останній лист;
2. довжина 5;
3. немає рівних літер поруч;
4. сума його чотирьох дельт алфавіту дорівнює нулю;
5. сума чотирьох знаків дельти алфавіту, що дорівнює нулю;
6. дві дельти позитивного алфавіту або дві негативні дельти алфавіту поспіль.

Усі, крім (1) та (рівнозначно) (4), можуть бути зведені до умови, що знаки дельти алфавіту є деяким обертанням [1,1,-1,-1](де знак 0є 0)

fireflame241 зазначив, що це еквівалентно дельтам дельти знаків дельти алфавіту, в [[2,2],[2,-2],[-2,2],[-2,-2]]яких можна перевірити абсолютні значення, що дорівнюють [2,2]!

Як?

=ṚḢȧOIṠIIA⁼Ø2 - Main link: word
 Ṛ            - reverse word
=             - equals? (vectorises)
  Ḣ           - head (is the first character equal to the last?)
   ȧ          - and
    O         - cast word to ordinals
     I        - increments - the alphabet deltas (or just [] if 1st != last)
      Ṡ       - sign (vectorises)
       I      - increments - deltas of those signs
        I     - increments - deltas of those
         A    - absolute value (vectorises)
           Ø2 - literal [2,2]
          ⁼   - equals? (non-vectorising version)

Java 8, 231 193 185 122 103 78 байт

s->s.length==5&&(s[1]-s[0])*(s[3]-s[2])<0&(s[2]-s[1])*(s[4]-s[3])<0&s[4]==s[0]

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

-38 байт завдяки @ dpa97 за те, що він нагадав мені використовувати char[]замість цього String.
-63 байти завдяки похідній формулі @KarlNapf .
-25 байт, перетворивши його з Java 7 в Java 8 (і тепер повертає булевий, а не цілий).

Відповідь 193 байт:

int c(char[]s){if(s.length!=5)return 0;int a=s[0],b=s[1],c=s[2],d=s[3],e=s[4],z=b-a,y=c-b,x=d-c,w=e-d;return e!=a?0:(z>0&y>0&x<0&w<0)|(z<0&y>0&x>0&w<0)|(z>0&y<0&x<0&w>0)|(z<0&y<0&x>0&w>0)?1:0;}

Пояснення:

• Якщо довжина рядка не дорівнює 5, повертаємося false
• Якщо перший символ не дорівнює останньому символу, ми повертаємося false
• Потім ми перевіряємо чотири дійсних випадки один за одним (вкажемо п'ять символів як 1 на 5) і повернемося, trueякщо він відповідає будь-якому з них ( falseінакше):
  1. Якщо п'ять символів розподілено так: 1<2<3>4>5(тобто ALPHA)
  2. Якщо п'ять символів розподілені так: 1>2<3<4>5(тобто EAGLE, HARSH, NINON, PINUP)
  3. Якщо п'ять символів розподілено так: 1<2>3>4<5(тобто RULER)
  4. Якщо п'ять символів розподілені як: 1>2>3<4<5(тобто THEFT, WIDOW)

Ці чотири правила можна спростити 1*3<0 and 2*4<0(завдяки відповіді @KarlNapf Python 2 ).

JavaScript (ES6), 91 89 87 байт

Збережено 2 байти завдяки Ісмаелю Мігелю

s=>(k=0,[...s].reduce((p,c,i)=>(k+=p>c?1<<i:0/(p<c),c)),k?!(k%3)&&!s[5]&&s[0]==s[4]:!1)

Як це працює

Ми будуємо 4-бітну маску, що kпредставляє 4 переходи між 5 символами рядка:

k += p > c ? 1<<i : 0 / (p < c)

• якщо попередній символ вище, ніж наступний, встановлюється біт
• якщо попередній символ нижчий, ніж наступний, біт не встановлюється
• якщо попередній символ ідентичний наступному, вся бітова маска змушена зробити NaNтак, щоб слово було відхилено (щоб відповідати правилу №6)

Дійсні бітові маски - це ті, що мають рівно два послідовних 1переходи (перший і останній біти також вважаються послідовними ):

Binary | Decimal
-------+--------
0011   | 3
0110   | 6
1100   | 12
1001   | 9

Іншими словами, це такі комбінації, які:

• k? : більше 0
• !(k%3): відповідає 0 модулю 3
• нижче 15

Інші умови:

• !s[5] : не більше 5 символів
• s[0]==s[4] : 1-й та 5-й символи однакові

NB : Ми не перевіряємо прямо, k != 15оскільки будь-яке слово, що слідує такому зразку, буде відхилено цією останньою умовою.

Тестові справи

let f =

s=>(k=0,[...s].reduce((p,c,i)=>(k+=p>c?1<<i:0/(p<c),c)),k?!(k%3)&&!s[5]&&s[0]==s[4]:!1)

console.log("Testing truthy words...");
console.log(f("ALPHA"));
console.log(f("EAGLE"));
console.log(f("HARSH"));
console.log(f("NINON"));
console.log(f("PINUP"));
console.log(f("RULER"));
console.log(f("THEFT"));
console.log(f("WIDOW"));

console.log("Testing falsy words...");
console.log(f("CUBIC"));
console.log(f("ERASE"));
console.log(f("FLUFF"));
console.log(f("LABEL"));
console.log(f("MODEM"));
console.log(f("RADAR"));
console.log(f("RIVER"));
console.log(f("SWISS"));
console.log(f("TRUST"));
console.log(f("KNEES"));
console.log(f("QUEEN"));
console.log(f("ORTHO"));
console.log(f("GROOVE"));
console.log(f("ONLY"));
console.log(f("CHARACTER"));
console.log(f("OFF"));
console.log(f("IT"));
console.log(f("ORTHO"));

Початкова версія

Для запису моя початкова версія склала 63 байти. Він проходить всі тестові випадки успішно, але не вдається виявити послідовно однакові символи.

([a,b,c,d,e,f])=>!f&&a==e&&!(((a>b)+2*(b>c)+4*(c>d)+8*(d>e))%3)

Нижче наведена 53-байтна версія, запропонована Нілом у коментарях, яка однаково добре працює:

([a,b,c,d,e,f])=>!f&&a==e&&!((a>b)-(b>c)+(c>d)-(d>e))

Редагувати: Дивіться відповідь Ніла на фіксовану / завершену версію вищевказаного коду.

JavaScript (ES6), 78 байт

([a,b,c,d,e,f])=>a==e&&!(f||/(.)\1/.test(a+b+c+d+e)||(a>b)-(b>c)+(c>d)-(d>e))

На основі неправильного коду @ Arnauld, але гольф і виправлений. Діє, попередньо перевіривши, що перший символ такий самий, як і п'ятий (гарантуючи таким чином 5 символів), і що довжина рядка не більше 5. Після перевірки на послідовні повторювані символи залишається перевірити хвилястість рядка, який повинен мати один пік і одну корито на дві літери.

• Якщо пік і жолоб - це середня та перша / остання літери, то перші дві порівняння та дві останні порівняння скасовуються
• Якщо вершина і корито є другою та четвертою літерами, то середні дві порівняння та дві зовнішні порівняння скасовуються
• В іншому випадку щось не вдасться скасувати, а загальний вираз повернеться хибним

Редагувати: Альтернативне 78-байтне рішення на основі відповіді @ KarlNapf:

([a,b,c,d,e,f],g=(a,b)=>(a<b)-(a>b))=>a==e&&!f&&g(a,b)*g(c,d)+g(b,c)*g(d,e)<-1

Код виходу Python 2, 56 байт

s=input()
v,w,x,y,z=map(cmp,s,s[1:]+s[0])
v*x+w*y|z>-2>_

Виводи за допомогою коду виходу: Помилка для помилкового та успішного запуску для True.

Бере рядок sз символами abcde, повертає його bcdea, робить порівнювання елементів відповідних символів і присвоює їм п'ять змінних v,w,x,y,z. Неправильна довжина дає помилку.

Слова нескінченності всі мають

v*x == -1
w*y == -1
z == 0

що можна спільно перевірити як v*x+w*y|z == -2. Якщо це стосується ланцюгового v*x+w*y|z>-2>_короткого замикання порівняння , інакше продовжується оцінка того, -2>_що дає помилку імені.

Пітон 2, 110 87 60 байт

Збереження 1 байта завдяки Нілу

Потрібен ввід, укладений у лапки, наприклад 'KNEES'

Trueякщо це слово нескінченності, Falseякщо ні, то воно має довжину 5 і друкує повідомлення про помилку, якщо неправильна довжина

s=input()
a,b,c,d,e=map(cmp,s,s[1:]+s[0])
print a*c+b*d|e<-1

Натхненний відповіддю xnor за допомогоюmap(cmp...

s=input()
e=map(cmp,s,s[1:]+s[0])
print e[4]==0and e[0]*e[2]+e[1]*e[3]==-2and 5==len(s)

попереднє рішення:

s=input()
d=[ord(x)-ord(y)for x,y in zip(s,s[1:])]
print s[0]==s[4]and d[0]*d[2]<0and d[1]*d[3]<0and 4==len(d)

Використовуючи оптимізовану логіку Кевіна Круїссена

PHP, 102 байти

for(;$i<strlen($w=$argv[1]);)$s.=($w[$i++]<=>$w[$i])+1;echo preg_match("#^(2200|0022|2002|0220)#",$s);

Python 2, 71 байт

lambda s:map(cmp,s,s[1:]+s[0])in[[m,n,-m,-n,0]for m in-1,1for n in-1,1]

Бере рядок sз символами abcde, обертає йогоbcdea та робить елементне порівняння відповідних символів.

a  b   cmp(a,b)
b  c   cmp(b,c)
c  d   cmp(c,d)
d  e   cmp(d,e)
e  a   cmp(e,a)

Результат - список -1, 0, 1 . Потім перевіряє, чи результат є однією з дійсних послідовностей підйомів і спадів:

[-1, -1, 1, 1, 0]
[-1, 1, 1, -1, 0]
[1, -1, -1, 1, 0]
[1, 1, -1, -1, 0]

як створено з шаблону [m,n,-m,-n,0]зm,n=±1 . Останній 0перевіряє, що перша та остання літера були рівними, а довжина забезпечує, щоб вхідна рядок мала довжину 5.

Альтернатива 71. Перевіряє умови порівнянь, забезпечуючи правильну довжину.

def f(s):a,b,c,d,e=map(cmp,s,s[1:]+s*9)[:5];print a*c<0==e>b*d>len(s)-7

R, 144 байти

Відповідь заснована на логіці @Jonathan Allan. Це, мабуть, могло бути гольф, хоча.

s=strsplit(scan(,""),"")[[1]];d=diff(match(s,LETTERS));s[1]==tail(s,1)&length(s)==5&all(!rle(s)$l-1)&!sum(d)&!sum(sign(d))&any(rle(sign(d))$l>1)

R-скрипкові тестові випадки (векторизований приклад, але така ж логіка)

GNU Prolog, 47 байт

i([A,B,C,D,A]):-A>B,B>C,C<D,D<A;i([B,C,D,A,B]).

Визначає присудок, iякий досягає успіху (нескінченно багато разів насправді) для слова нескінченності, виводячи таким чином "так" під час запуску з інтерпретатора (як це звичайно для Prolog); не відповідає слову-кандидату, перша і остання літера якого не збігаються або не має 5 літер, таким чином виводячи "ні" при запуску з перекладача; і збої з переповненням стека, якщо дано слово-кандидат, яке не є нескінченним словом, але це п'ять літер з першою та останніми двома відповідністю. (Я не впевнений, чомувін руйнується; рекурсивний виклик повинен піддаватися лікуванню як зворотний дзвінок. Мабуть, оптимізатор GNU Prolog не дуже хороший.) Успіх - це еквівалент Прологу, який є трибуном, і невдалий еквівалент фальси; аварія, безумовно, більше фальсифікація, ніж правда, і її виправлення зробить рішення значно довшим, тому я сподіваюся, що це вважається правильним рішенням.

Алгоритм досить простий (і дійсно, програма досить читабельна); перевірте, чи букви утворюють один із чотирьох шаблонів, що складають слово нескінченності, а якщо ні, циклічно перестановіть та спробуйте ще раз. Нам не потрібно явно перевірити для подвійних букв , як <і >оператори дозволяють нам неявно перевірити , що в той же самий час , що ми перевіряємо , що дельти збігаються.

Власне , 38 27 байт

Ця відповідь в значній мірі надихнула відмінну відповідь Джонатана Аллана Желе . Напевно, є кілька місць, де це можна пограти в гольф, тому пропозиції щодо гольфу вітаються! Спробуйте в Інтернеті!

O;\♀-dY@♂s4R`0~;11({k`Míub*

Ungolfing

     Implicit input s.
O    Push the ordinals of s. Call this ords.
;    Duplicate ords.
\    Rotate one duplicate of ords left by 1.
♀-   Vectorized subtraction. This effectively gets the first differences of ords.
d    Pop ord_diff[-1] onto the stack. This is ords[0] - ords[-1].
Y    Logical negate ord_diff[-1], which returns 1 if s[0] == s[-1], else 0.
@    Swap (s[0] == s[-1]) with the rest of ord_diff.

♂s       Vectorized sgn() of ord_diff. This gets the signs of the first differences.
4R       Push the range [1..4] onto the stack.
`...`M   Map the following function over the range [1..4]. Variable x.
  0~;      Push -1 onto the stack twice.
  11       Push 1 onto the stack twice.
  (        Rotate x to TOS.
  {        Rotate the stack x times, effectively rotating the list [1, 1, -1, -1].
  k        Wrap it all up in a list.

     Stack: list of rotations of [1, 1, -1, -1], sgn(*ord_diff)
í    Get the 0-based index of sgn(*ord_diff) from the list of rotations. -1 if not found.
ub   This returns 1 only if sgn(*ord_diff) was found, else 0.
     This checks if the word loops like an infinity word.

*    Multiply the result of checking if the word s loops and the result of s[0] == s[-1].
     Implicit return.

APL (Dyalog) , 16 15 байт

0=16|3⊥×2-/⎕a⍳⍞

Спробуйте в Інтернеті!

TI-BASIC, 81 байт

Рядок для передачі в програму знаходиться в Ans. Повертає (і неявно відображає) 1, якщо введене слово - це слово нескінченності, і 0 (або виходить із повідомленням про помилку), якщо це не так.

seq(inString("ABCDEFGHIJKLMNOPQRSTUVWXYZ",sub(Ans,A,1)),A,1,length(Ans
min(Ans(1)=Ans(5) and {2,2}=abs(deltaList(deltaList(deltaList(Ans)/abs(deltaList(Ans

Помилки будь-яких повторних символів або не-5-літерних слів.

05AB1E , 16 байт

Ç¥DO_s.±¥¥Ä2DиQ*

Порт відповіді Желнатана Аллана .

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

Пояснення:

Ç             # Convert the (implicit) input string to a list of unicode values
              #  i.e. "RULES" → [82,85,76,69,82]
 ¥            # Take the deltas
              #  i.e. [82,85,76,69,82] → [3,-9,-7,13]
  DO          # Duplicate and take the sum
              #  i.e. [3,-9,-7,13] → 0
    _         # Check if that sum is exactly 0
              # (which means the first and last characters are equal)
              #  i.e. 0 and 0 → 1 (truthy)
 s            # Swap so the deltas are at the top of the stack again
  .±          # Get the sign of each
              #  i.e. [3,-9,-7,13] → [1,-1,-1,1]
    ¥         # Get the deltas of those signs
              #  i.e. [1,-1,-1,1] → [-2,0,2]
     ¥        # And then get the deltas of those
              #  i.e. [-2,0,2] → [2,2]
      Ä       # Convert them to their absolute values
       2Dи    # Repeat the 2 two times as list: [2,2]
          Q   # Check if they are equal
              #  i.e. [2,2] and [2,2] → 1 (truthy)
 *            # Check if both are truthy (and output implicitly)
              #  i.e. 1 and 1 → 1 (truthy)