(Uwaga: jest to spin-off mojego poprzedniego wyzwania Find the Swirling Words! )

Definicja słowa nieskończoności :

1. Jeśli połączysz za pomocą krzywych wszystkie znaki Słowa Nieskończoności z alfabetu (AZ), otrzymasz symbol nieskończoności ∞ jak na poniższych schematach.
2. Wszystkie połączenia parzyste muszą być wyłączone , wszystkie połączenia nieparzyste muszą być uruchomione .
3. Możesz zignorować wielkie / małe litery lub rozważyć / przekonwertować wszystkie na wielkie lub wszystkie na małe.
4. Słowa wejściowe to tylko znaki z zakresu alfabetu AZ, bez spacji, interpunkcji i symboli.
5. Każde słowo musi mieć dokładnie 5 znaków. Słowa> 5 lub <5 są nieprawidłowe.
6. Jeśli słowo ma dwa kolejne znaki, jest ono niepoprawne, na przykład „POWODZIE” lub „KRÓLOWA”.
7. Wszystkie Słowa Nieskończoności zaczynają się i kończą tą samą postacią.

Oto kilka przykładów:

Zadanie:

Napisz pełny program lub funkcję, która pobierze słowo ze standardowego wejścia i wyświetli, czy jest to Słowo Nieskończoności, czy nie. Dane wyjściowe mogą mieć wartość true / false, 1/0, 1 / Null itp.

Przypadki testowe:

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

Zasady:

1. Najkrótszy kod wygrywa.

Opcjonalne zadanie:

Znajdź, jako listę, tyle słów nieskończoności w słowniku angielskim. Możesz wziąć przykładowo pełną listę angielskich słów tutaj .

Galaretka , 43 41 40 25 24 23 22 21 14 13 bajtów

-7 bajtów dzięki fireflame241 ( 0ị=1ị$-> =ṚḢi użycie IIA⁼2,2do testowania 4 obrotów)

-1 Dzięki Kevin Cruijssen (użycie wcześniej niedostępnego nilada, Ø2który daje [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
Lub wszystkie przypadki testowe (plus „ZASADY”)

W jaki sposób?

Słowo nieskończoności ma:

1. ten sam pierwszy i ostatni list;
2. długość 5;
3. brak równych liter obok siebie;
4. suma czterech delt alfabetu równa zero;
5. suma czterech znaków delta alfabetu równa zero;
6. dwie dodatnie delty alfabetu lub dwie ujemne delty alfabetu z rzędu.

Wszystkie oprócz (1) i (równoważnie) (4) można sprowadzać do warunku, że znaki delta alfabetu są pewną rotacją [1,1,-1,-1](gdzie znakiem 0jest0 )

fireflame241 zauważył, że jest to równoważne z deltami znaków delty alfabetu, w [[2,2],[2,-2],[-2,2],[-2,-2]]których mogą być testowane przy wartościach bezwzględnych równych [2,2]!

W jaki sposób?

=ṚḢȧ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 bajtów

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]

Wypróbuj tutaj.

-38 bajtów dzięki @ dpa97 za przypomnienie, żebym użył char[]zamiast String.
-63 bajty dzięki formule pochodnej @KarlNapf .
-25 bajtów poprzez konwersję z Java 7 na Java 8 (i teraz zwraca wartość logiczną zamiast liczby całkowitej).

193 bajty odpowiedzi:

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

Wyjaśnienie:

• Jeśli długość łańcucha nie wynosi 5, zwracamy false
• Jeśli pierwszy znak nie jest równy ostatniemu, wracamy false
• Następnie sprawdzamy cztery ważne przypadki jeden po drugim (oznaczmy pięć znaków jako 1 do 5) i wracamy true jeśli jest zgodny z którymkolwiek z nich (i falseinaczej):
  1. Jeśli pięć znaków jest rozmieszczonych w następujący sposób: 1<2<3>4>5 (tj. ALPHA)
  2. Jeśli pięć znaków są rozmieszczone tak: 1>2<3<4>5(to znaczy EAGLE,HARSH , NINON,PINUP )
  3. Jeśli pięć znaków jest rozmieszczonych w następujący sposób: 1<2>3>4<5 (tj. RULER)
  4. Jeśli pięć znaków są rozmieszczone tak: 1>2>3<4<5(to znaczy THEFT, WIDOW)

Te cztery reguły można uprościć 1*3<0 and 2*4<0(dzięki odpowiedzi @KarlNapf w Python 2 ).

JavaScript (ES6), 91 89 87 bajtów

Zaoszczędzono 2 bajty dzięki Ismaelowi Miguelowi

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)

Jak to działa

Budujemy 4-bitową maskę bitową kreprezentującą 4 przejścia między 5 znakami ciągu:

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

• jeśli poprzedni znak jest wyższy niż następny, bit jest ustawiany
• jeśli poprzedni znak jest niższy niż następny, bit nie jest ustawiony
• jeśli poprzedni znak jest identyczny z następnym, cała maska ​​bitowa jest zmuszona, aby NaNsłowo zostało odrzucone (w celu spełnienia zasady nr 6)

Prawidłowe maski bitowe to te, które mają dokładnie dwa kolejne 1przejścia (pierwszy i ostatni bit są również uważane za kolejne ):

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

Innymi słowy, są to kombinacje, które są:

• k? : większa niż 0
• !(k%3): przystający do 0 modulo 3
• mniej niż 15

Pozostałe warunki to:

• !s[5] : nie ma więcej niż 5 znaków
• s[0]==s[4] : 1. i 5. znak są identyczne

Uwaga : Nie sprawdzamy wyraźnie, k != 15ponieważ każde słowo następujące po takim wzorze zostanie odrzucone przez ten ostatni warunek.

Przypadki testowe

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

Początkowa wersja

Dla przypomnienia, moja początkowa wersja miała 63 bajty. Pomyślnie przechodzi wszystkie przypadki testowe, ale nie wykrywa kolejnych identycznych znaków.

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

Poniżej znajduje się 53-bajtowa wersja sugerowana przez Neila w komentarzach, która działa (i kończy się niepowodzeniem) równie dobrze:

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

Edycja: Zobacz odpowiedź Neila na poprawioną / ukończoną wersję powyższego kodu.

JavaScript (ES6), 78 bajtów

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

Na podstawie niepoprawnego kodu @ Arnauld, ale grał w golfa i poprawił. Działa, sprawdzając najpierw, czy pierwszy znak jest taki sam jak piąty (gwarantując w ten sposób 5 znaków) i czy długość łańcucha nie przekracza 5. Po sprawdzeniu kolejnych duplikatów znaków pozostaje sprawdzenie falistości łańcucha, który powinien mieć jeden pik i jedną dolną dwie litery od siebie.

• Jeśli szczyt i dołek są środkową i pierwszą / ostatnią literą, wówczas pierwsze dwa porównania i ostatnie dwa porównania anulują
• Jeśli szczyt i dołek to druga i czwarta litera, wówczas dwa środkowe porównania i dwa zewnętrzne porównania anulują
• W przeciwnym razie coś nie zostanie anulowane, a ogólne wyrażenie zwróci false

Edycja: Alternatywne 78-bajtowe rozwiązanie oparte na odpowiedzi @ 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

Kod wyjścia Python 2, 56 bajtów

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

Dane wyjściowe za pośrednictwem kodu wyjścia: Błąd dla False i pomyślne uruchomienie dla True.

Pobiera ciąg znaków sze znakami abcde, obraca go bcdea, dokonuje elementarnego porównania odpowiednich znaków i przypisuje je do pięciu zmiennych v,w,x,y,z. Zła długość powoduje błąd.

Wszystkie słowa nieskończoności mają

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

które można sprawdzić łącznie jako v*x+w*y|z == -2. W v*x+w*y|z>-2>_takim przypadku zwarcie w łańcuchu porównawczym powoduje zwarcie, a w przeciwnym razie przechodzi do oceny, -2>_która daje błąd nazwy.

Python 2, 110 87 60 bajtów

Oszczędność 1 bajtu dzięki Neilowi

Wymaga danych wejściowych ujętych w cudzysłów, np 'KNEES'

Truejeśli jest to słowo nieskończoności, Falsejeśli nie i ma długość 5 i wyświetla komunikat o błędzie, jeśli jest niepoprawny

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

Zainspirowany XNOR „s odpowiedź za pomocą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)

poprzednie rozwiązanie:

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)

Korzystanie ze zoptymalizowanej logiki Kevina Cruijssena

PHP, 102 bajtów

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

Python 2, 71 bajtów

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

Pobiera ciąg znaków sze znakami abcde, obraca go bcdeai dokonuje elementarnego porównania odpowiednich znaków.

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)

Wynikiem jest lista -1, 0, 1. Następnie sprawdza, czy wynik jest jedną z prawidłowych sekwencji wzlotów i upadków:

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

wygenerowane z szablonu za [m,n,-m,-n,0]pomocąm,n=±1 . Ostatnie 0sprawdzenie, czy pierwsza i ostatnia litera były równe, a długość zapewnia, że ​​łańcuch wejściowy miał długość 5.

Alternatywa 71. Sprawdza warunki porównań, zapewniając odpowiednią długość.

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 bajty

Odpowiedź opiera się na logice @Jonathan Allan. Prawdopodobnie można go grać w golfa.

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)

Przypadki testowe skrzypiec R (przykład wektorowy, ale ta sama logika)

GNU Prolog, 47 bajtów

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

Definiuje predykat, który ulega awarii; połączenie rekurencyjne powinno być traktowane jak rozmowa. Najwyraźniej optymalizator GNU Prolog nie jest zbyt dobry.) Osiągnięcie sukcesu to odpowiednik prawdy w Prologu, a porażka odpowiednika falsey; awaria jest zdecydowanie bardziej falsey niż prawdą, a naprawienie go znacznie wydłużyłoby rozwiązanie, więc mam nadzieję, że liczy się to jako prawidłowe rozwiązanie.i któremu udaje się (w rzeczywistości nieskończenie wiele razy) dla słowa nieskończoności, w ten sposób wypisując „tak” po uruchomieniu z interpretera (jak to zwykle bywa w Prologu); nie odpowiada słowu kandydującemu, którego pierwsza i ostatnia litera nie pasują do siebie, lub nie jest długa na 5 liter, co powoduje wyświetlenie „nie” po uruchomieniu z interpretera; i ulega awarii z przepełnieniem stosu, jeśli podano słowo kandydujące, które nie jest słowem nieskończoności, ale składa się z pięciu liter z dopasowaniem pierwszych i ostatnich dwóch. (Nie jestem pewien dlaczego

Algorytm jest dość prosty (i rzeczywiście program jest dość czytelny); sprawdź, czy litery tworzą jeden z czterech wzorów tworzących słowo nieskończoności, a jeśli nie, zacznij cyklicznie permutować i spróbuj ponownie. Nie musimy jawnie sprawdzać podwójnych liter, ponieważ operatory <i >pozwalają nam domyślnie sprawdzić, czy w tym samym czasie sprawdzamy, czy delty są zgodne.

Faktycznie , 38 27 bajtów

Ta odpowiedź była w dużej mierze zainspirowana doskonałą odpowiedzią Jonathana Allana na galaretkę . Prawdopodobnie jest kilka miejsc, w których można grać w golfa, więc sugestie dotyczące gry w golfa są mile widziane! Wypróbuj online!

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 bajtów

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

Wypróbuj online!

TI-BASIC, 81 bajtów

Ciąg do przekazania do programu znajduje się w Ans. Zwraca (i domyślnie wyświetla) 1, jeśli wprowadzone słowo jest Słowem Nieskończoności, i 0 (lub kończy pracę z komunikatem o błędzie), jeśli nie jest.

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

Błędy powtarzających się znaków lub słów nie zawierających 5 liter.

05AB1E , 16 bajtów

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

Port odpowiedzi galaretki @JonathanAllan .

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Ç             # 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)