（注意：这是我以前的挑战“ 发现旋流词”的副产品！）

无限词的定义：

1. 如果使用曲线连接字母（AZ）上无穷大字的所有字符，则将获得无穷大符号∞，如下图所示。
2. 所有甚至连接必须下来，所有的奇数连接必须起来。
3. 您可以忽略大写/小写或全部考虑/转换为大写或全部转换为小写。
4. 输入的单词仅是AZ字母范围内的字符，没有空格，标点符号或符号。
5. 每个单词必须正好是5个字符。单词> 5或<5无效。
6. 如果单词具有两个连续的字符，则该单词无效，例如“ FLOOD”或“ QUEEN”。
7. 所有无穷词以相同的字符开始和结束。

这里有一些例子：

任务：

编写一个完整的程序或函数，该程序或函数将从标准输入中提取一个单词，然后输出是否为无穷大字。输出可以是true / false，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感谢Kevin Cruijssen（使用以前无法获得的nilad Ø2产生[2,2]）

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
或所有测试用例（加上“规则”）

怎么样？

一个无穷大的词有：

1. 相同的首字母和尾字母；
2. 长度5;
3. 彼此之间没有相等的字母；
4. 它的四个字母增量的总和等于零；
5. 它的四个字母增量符号的总和等于零；
6. 连续两个正字母增量或两个负字母增量。

除了（1）和（等价）（4）以外的所有内容都可以归结为字母δ符号是[1,1,-1,-1]（的符号0为0）旋转的条件

fireflame241指出，这等效于字母delta符号的delta中的delta，[[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)

爪哇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的派生公式。
通过将其从Java 7转换为Java 8（现在返回布尔值而不是整数）来获得-25个字节。

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字节

由于Ismael Miguel节省了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表示该字符串的5个字符之间的4个转换：

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] ：第一个和第五个字符相同

注意：我们没有明确检查，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)

以下是Neil在评论中建议的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个。在检查了连续的重复字符后，仍然需要检查字符串的波纹度，其中一个峰顶和一个谷底应分开两个字母。

• 如果波峰和波谷是中间字母和前一个字母/后一个字母，则前两个比较和后两个比较会抵消
• 如果波峰和波谷是第二个和第四个字母，则中间的两个比较和外面的两个比较会抵消
• 否则，某些操作无法取消并且整个表达式返回false

编辑：基于@KarlNapf的答案的替代的78字节解决方案：

([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>_

通过退出代码输出：错误为False，成功运行为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>_，这会产生名称错误。

Python 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)

使用Kevin Cruijssen的优化逻辑

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个字母的候选单词失败，因此从解释器运行时输出“ no”；如果给出的候选词不是无穷大，而是五个字母，且前两个匹配，则崩溃并导致堆栈溢出。（我不确定为什么它崩溃了；递归调用应被视为尾调用。显然，GNU Prolog的优化器不是很好。）成功是Prolog的“真”，而失败的是“假”。崩溃绝对比事实更虚假，而修复它会使解决方案更长的时间，因此我希望这可以算是有效的解决方案。

该算法非常简单（实际上，该程序可读性很强）；检查字母是否构成构成无穷大词的四个模式之一，如果不是，则循环排列并重试。我们不需要显式检查双字母，因为<and >运算符使我们可以在检查增量匹配的同时隐式检查。

实际上，38 27个字节

这个答案很大程度上受到乔纳森·艾伦（Jonathan Allan）出色的果冻答案的启发。可能有几个地方可以打高尔夫球，因此欢迎打高尔夫球！在线尝试！

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

开球

     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*

@JonathanAllan的Jelly答案端口。

在线尝试或验证所有测试用例。

说明：

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