(Hinweis: Dies ist ein Ableger meiner vorherigen Herausforderung " Find the Swirling Words"! )

Definition von Infinity Word :

1. Wenn Sie alle Zeichen eines Unendlichkeitsworts auf dem Alphabet (AZ) mit Kurven verbinden , erhalten Sie das Unendlichkeitssymbol ∞ wie in den folgenden Diagrammen.
2. Alle geraden Verbindungen müssen unterbrochen sein , alle ungeraden Verbindungen müssen aktiviert sein .
3. Sie können Groß- / Kleinschreibung ignorieren oder alle in Groß- oder Kleinschreibung umwandeln.
4. Die eingegebenen Wörter sind nur Zeichen im alphabetischen Bereich von AZ, keine Leerzeichen, keine Interpunktion oder Symbole.
5. Jedes Wort muss genau 5 Zeichen enthalten. Wörter> 5 oder <5 sind ungültig.
6. Wenn ein Wort aus zwei aufeinanderfolgenden Zeichen besteht, ist das Wort ungültig, z. B. "FLOOD" oder "QUEEN".
7. Alle Unendlichkeitswörter beginnen und enden mit demselben Zeichen.

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 Unendlichkeitswort handelt oder nicht. Die Ausgabe kann wahr / falsch, 1/0, 1 / Null usw. sein.

Testfälle:

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

Regeln:

1. Kürzester Code gewinnt.

Optionale Aufgabe:

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

Jelly , 43 41 40 25 24 23 22 21 14 13 Bytes

-7 Bytes dank fireflame241 ( 0ị=1ị$-> =ṚḢund IIA⁼2,2Test für die 4 Umdrehungen)

-1 Dank Kevin Cruijssen (Nutzung von bisher nicht nilad Ø2welche Erträge [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
oder alle Testfälle (plus "REGELN")

Wie?

Ein Unendlichkeitswort hat:

1. der gleiche erste und letzte Buchstabe;
2. Länge 5;
3. keine gleichen Buchstaben nebeneinander;
4. Summe seiner vier Alphabet-Deltas gleich Null;
5. Summe seiner vier alphabetischen Deltazeichen gleich Null;
6. zwei positive Alphabet-Deltas oder zwei negative Alphabet-Deltas in einer Reihe.

Alle außer (1) und (äquivalent) (4) können auf eine Bedingung heruntergekocht werden, dass die Alphabet-Delta-Zeichen eine Rotation von [1,1,-1,-1](wobei das Zeichen von 0ist 0) sind.

fireflame241 merkte an, dass dies dann äquivalent zu den Deltas der Deltas der alphabetischen Deltazeichen ist, in [[2,2],[2,-2],[-2,2],[-2,-2]]denen getestet werden kann, indem die absoluten Werte gleich sind [2,2]!

Wie?

=ṚḢȧ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 Bytes

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]

Probieren Sie es hier aus.

-38 bytes danke an @ dpa97 für die erinnerung , dass ich char[]anstelle von verwende String.
-63 Bytes dank der von @KarlNapf abgeleiteten Formel.
-25 Byte durch Konvertieren von Java 7 in Java 8 (und Rückgabe eines Booleschen Werts anstelle einer Ganzzahl).

193 Bytes Antwort:

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

Erläuterung:

• Wenn die Länge des Strings nicht 5 ist, kehren wir zurück false
• Wenn das erste Zeichen nicht dem letzten Zeichen entspricht, kehren wir zurück false
• Dann überprüfen wir die vier gültigen Fälle nacheinander (lassen Sie uns die fünf Zeichen als 1 bis 5 angeben) und geben zurück, trueob sie mit einem von ihnen übereinstimmen (und falseansonsten):
  1. Wenn die fünf Zeichen wie folgt verteilt sind: 1<2<3>4>5(ie ALPHA)
  2. Wenn die fünf Zeichen sind verteilt wie: 1>2<3<4>5(dh EAGLE, HARSH, NINON, PINUP)
  3. Wenn die fünf Zeichen wie folgt verteilt sind: 1<2>3>4<5(ie RULER)
  4. Wenn die fünf Zeichen sind verteilt wie: 1>2>3<4<5(dh THEFT, WIDOW)

Diese vier Regeln können vereinfacht werden 1*3<0 and 2*4<0(dank der Antwort von @KarlNapf auf Python 2 ).

JavaScript (ES6), 91 89 87 Byte

2 Bytes dank Ismael Miguel gespeichert

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)

Wie es funktioniert

Wir erstellen eine 4-Bit-Bitmaske, kdie die 4 Übergänge zwischen den 5 Zeichen der Zeichenfolge darstellt:

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

• Ist das vorherige Zeichen höher als das nächste, wird das Bit gesetzt
• Ist das vorherige Zeichen niedriger als das nächste, wird das Bit nicht gesetzt
• Wenn das vorherige Zeichen mit dem nächsten Zeichen identisch ist, wird die gesamte Bitmaske gezwungen NaN, das Wort abzulehnen (um Regel 6 zu erfüllen).

Die gültigen Bitmasken haben genau zwei aufeinanderfolgende 1Übergänge (das erste und das letzte Bit werden ebenfalls als aufeinanderfolgend betrachtet ):

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

Mit anderen Worten, dies sind die Kombinationen, die sind:

• k? : größer als 0
• !(k%3): kongruent zu 0 Modulo 3
• niedriger als 15

Die anderen Bedingungen sind:

• !s[5] : Es gibt nicht mehr als 5 Zeichen
• s[0]==s[4] : Das 1. und das 5. Zeichen sind identisch

NB : Wir prüfen dies nicht explizit, k != 15da jedes Wort, das einem solchen Muster folgt, von dieser letzten Bedingung abgelehnt wird.

Testfälle

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

Erste Version

Für den Datensatz war meine ursprüngliche Version 63 Bytes. Es besteht alle Testfälle erfolgreich, erkennt jedoch keine aufeinander folgenden identischen Zeichen.

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

Unten finden Sie eine 53-Byte-Version, die Neil in den Kommentaren vorgeschlagen hat und die genauso gut funktioniert (und auch fehlschlägt):

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

Bearbeiten: Siehe Neils Antwort für die feste / vervollständigte Version des obigen Codes.

JavaScript (ES6), 78 Byte

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

Basierend auf @ Arnauld's falschem Code, aber golfen und korrigiert. Überprüfen Sie zunächst, ob das erste Zeichen mit dem fünften Zeichen identisch ist (wodurch 5 Zeichen garantiert werden) und ob die Länge der Zeichenfolge nicht mehr als 5 beträgt. die sollte eine Spitze und eine Talsohle zwei Buchstaben voneinander entfernt haben.

• Wenn die Spitze und die Talsohle die mittleren und ersten / letzten Buchstaben sind, werden die ersten beiden Vergleiche und die letzten beiden Vergleiche aufgehoben
• Wenn der Peak und der Trog der zweite und der vierte Buchstabe sind, werden die beiden mittleren Vergleiche und die beiden äußeren Vergleiche aufgehoben
• Andernfalls kann etwas nicht abgebrochen werden und der Gesamtausdruck gibt false zurück

Bearbeiten: Alternative 78-Byte-Lösung basierend auf der Antwort von @ 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-Exit-Code, 56 Byte

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

Ausgabe über Exit-Code: Fehler bei False und erfolgreicher Lauf bei True.

Nimmt die Zeichenfolge smit abcde, dreht sie auf bcdea, vergleicht die entsprechenden Zeichen elementweise und weist sie fünf Variablen zu v,w,x,y,z. Die falsche Länge gibt einen Fehler.

Die unendlichen Worte haben alle

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

die gemeinsam geprüft werden können als v*x+w*y|z == -2. Der verkettete Vergleich v*x+w*y|z>-2>_schließt in diesem Fall kurz und wertet ansonsten aus, -2>_was zu einem Namensfehler führt.

Python 2, 110 87 60 Bytes

1 Byte sparen dank Neil

Erfordert die Eingabe in Anführungszeichen, z 'KNEES'

TrueWenn es ein unendliches Wort ist, Falsewenn nicht, hat es eine Länge von 5 und gibt eine Fehlermeldung aus, wenn die Länge falsch ist

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

Inspiriert von xnors Antwort mitmap(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)

vorherige Lösung:

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)

Verwendung der optimierten Logik von Kevin Cruijssen

PHP, 102 Bytes

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

Python 2, 71 Bytes

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

Nimmt die Zeichenfolge smit abcde, dreht sie zu bcdeaund führt einen elementweisen Vergleich der entsprechenden Zeichen durch.

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)

Das Ergebnis ist eine Liste von -1, 0, 1. Überprüft dann, ob das Ergebnis eine der gültigen Folgen von Auf und Ab ist:

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

wie aus der Vorlage [m,n,-m,-n,0]mit erzeugt m,n=±1. Das letzte Mal wird 0überprüft, ob der erste und der letzte Buchstabe gleich sind, und die Länge stellt sicher, dass die Eingabezeichenfolge die Länge 5 hat.

Eine Alternative 71. Überprüft die Bedingungen für Vergleiche und stellt dabei die richtige Länge sicher.

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 Bytes

Die Antwort basiert auf der Logik von Jonathan Allan. Es könnte aber wahrscheinlich Golf gespielt werden.

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-Geigen-Testfälle (vektorisiertes Beispiel, aber gleiche Logik)

GNU Prolog, 47 Bytes

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

Definiert ein Prädikat, idas (tatsächlich unendlich oft) für ein Unendlichkeitswort erfolgreich ist und somit "yes" ausgibt, wenn es vom Interpreter ausgeführt wird (wie es für Prolog üblich ist). schlägt für ein Kandidatenwort fehl, dessen erster und letzter Buchstabe nicht übereinstimmen oder nicht 5 Buchstaben lang sind, und gibt daher "nein" aus, wenn es vom Interpreter ausgeführt wird; und stürzt mit einem Stapelüberlauf ab, wenn ein Kandidatenwort angegeben wird, das kein unendliches Wort ist, sondern aus fünf Buchstaben besteht, wobei die ersten beiden Buchstaben übereinstimmen. (Ich weiß nicht warumes stürzt ab; Der rekursive Aufruf sollte als Tailcall behandelt werden können. Anscheinend ist der Optimierer von GNU Prolog nicht sehr gut. Ein Absturz ist definitiv falscher als wahr, und wenn er behoben wird, würde die Lösung erheblich länger dauern. Daher hoffe ich, dass dies als gültige Lösung gilt.

Der Algorithmus ist ziemlich einfach (und in der Tat ist das Programm ziemlich lesbar); Überprüfen Sie, ob die Buchstaben eines der vier Muster bilden, aus denen ein Unendlichkeitswort besteht. Wenn nicht, permutieren Sie zyklisch und versuchen Sie es erneut. Wir brauchen nicht explizit für Doppelbuchstaben zu überprüfen , wie die <und >Betreiber lassen Sie uns prüfen, ob implizit zur gleichen Zeit , dass wir prüfen, ob die Deltas entsprechen.

Eigentlich , 38 27 Bytes

Diese Antwort wurde weitgehend von Jonathan Allans hervorragender Gelee-Antwort inspiriert . Es gibt wahrscheinlich mehrere Orte, an denen Golf gespielt werden kann, also sind Golfvorschläge willkommen! Probieren Sie es 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 Bytes

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

Probieren Sie es online!

TI-BASIC, 81 Bytes

Die an das Programm zu übergebende Zeichenfolge befindet sich in Ans. Gibt 1 zurück (und zeigt dies implizit an), wenn das eingegebene Wort ein Unendlichkeitswort ist, und 0 (oder wird mit einer Fehlermeldung beendet), wenn dies nicht der Fall ist.

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

Fehler bei wiederholten Zeichen oder Nicht-5-Buchstaben-Wörtern.

05AB1E , 16 Bytes

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

Port of Jonathan Allans Gelee Antwort .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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