(Lưu ý: Đây là phần phụ của thử thách trước đây của tôi Tìm các từ xoáy! )

Định nghĩa của Infinity Word :

1. Nếu bạn kết nối với các đường cong tất cả các ký tự của Infinity Word trên bảng chữ cái (AZ), bạn sẽ có được biểu tượng vô cực ∞ như trong các sơ đồ bên dưới.
2. Tất cả các kết nối chẵn phải xuống , tất cả các kết nối lẻ phải được lên .
3. Bạn có thể bỏ qua chữ hoa / chữ thường hoặc xem xét / chuyển đổi tất cả sang chữ hoa hoặc tất cả sang chữ thường.
4. Các từ đầu vào chỉ là các ký tự trong phạm vi bảng chữ cái của AZ, không có dấu cách, không có dấu chấm câu hoặc ký hiệu.
5. Mỗi từ phải chính xác 5 ký tự. Các từ> 5 hoặc <5 không hợp lệ.
6. Nếu một từ có hai ký tự liên tiếp, từ đó không hợp lệ, như "HOA" hoặc "QUEEN".
7. Tất cả các từ vô cực bắt đầu và kết thúc với cùng một nhân vật.

Dưới đây là một số ví dụ:

Bài tập:

Viết một chương trình hoặc chức năng đầy đủ sẽ lấy một từ từ đầu vào tiêu chuẩn và sẽ xuất ra nếu là Infinity Word hay không. Đầu ra có thể đúng / sai, 1/0, 1 / Null, v.v.

Các trường hợp thử nghiệm:

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

Quy tắc:

1. Mã ngắn nhất sẽ thắng.

Nhiệm vụ tùy chọn:

Tìm, dưới dạng một danh sách, càng nhiều từ Vô cực càng tốt trong từ điển tiếng Anh. Bạn có thể lấy ví dụ như tham khảo danh sách đầy đủ các từ tiếng Anh ở đây .

Thạch , 43 41 40 25 24 23 22 21 14 13 byte

-7 byte nhờ fireflame241 ( 0ị=1ị$-> =ṚḢvà sử dụng IIA⁼2,2để kiểm tra 4 vòng quay)

-1 Nhờ Kevin Cruijssen (sử dụng nilad trước đây không có Ø2mà sản lượng [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
Hoặc tất cả các trường hợp thử nghiệm (cộng với "RULES")

Làm sao?

Một từ vô cực có:

1. cùng một chữ cái đầu tiên và cuối cùng;
2. dài 5;
3. không có chữ cái nào cạnh nhau;
4. tổng của bốn deltas bảng chữ cái của nó bằng không;
5. tổng của bốn dấu hiệu deltas bảng chữ cái của nó bằng không;
6. hai deltas bảng chữ cái tích cực hoặc hai deltas bảng chữ cái tiêu cực liên tiếp.

Tất cả nhưng (1) và (tương đương) (4) có thể được luộc xuống đến một điều kiện là những dấu hiệu đồng bằng bảng chữ cái là một số vòng quay của [1,1,-1,-1](nơi dấu hiệu 0là 0)

fireflame241 lưu ý rằng điều này sau đó tương đương với đồng bằng châu thổ của các dấu hiệu delta bảng chữ cái đang [[2,2],[2,-2],[-2,2],[-2,-2]]được kiểm tra bởi các giá trị tuyệt đối bằng [2,2]!

Làm sao?

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

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]

Hãy thử nó ở đây.

-38 byte nhờ @ dpa97 đã nhắc nhở tôi sử dụng char[]thay vì String.
-63 byte nhờ công thức dẫn xuất của @KarlNapf .
-25 byte bằng cách chuyển đổi nó từ Java 7 sang Java 8 (và bây giờ trả về một boolean thay vì số nguyên).

Câu trả lời 193 byte:

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

Giải trình:

• Nếu độ dài của chuỗi không phải là 5, chúng tôi sẽ trả về false
• Nếu ký tự đầu tiên không bằng ký tự cuối cùng, chúng tôi sẽ quay lại false
• Sau đó, chúng tôi kiểm tra bốn trường hợp hợp lệ từng cái một (hãy chỉ ra năm ký tự từ 1 đến 5) và trả về truenếu nó tuân thủ bất kỳ trường hợp nào trong số chúng (và falsenếu không):
  1. Nếu năm ký tự được phân phối như: 1<2<3>4>5(tức là ALPHA)
  2. Nếu năm nhân vật được phân bố như sau: 1>2<3<4>5(ví dụ EAGLE, HARSH, NINON, PINUP)
  3. Nếu năm ký tự được phân phối như: 1<2>3>4<5(tức là RULER)
  4. Nếu năm nhân vật được phân bố như sau: 1>2>3<4<5(ví dụ THEFT, WIDOW)

Bốn quy tắc này có thể được đơn giản hóa 1*3<0 and 2*4<0(nhờ câu trả lời Python 2 của @KarlNapf ).

JavaScript (ES6), 91 89 87 byte

Đã lưu 2 byte nhờ Ismael Miguel

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)

Làm thế nào nó hoạt động

Chúng tôi xây dựng một bitmask 4 bit kđại diện cho 4 lần chuyển đổi giữa 5 ký tự của chuỗi:

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

• nếu ký tự trước cao hơn ký tự tiếp theo, bit được đặt
• nếu ký tự trước thấp hơn ký tự tiếp theo, bit không được đặt
• nếu ký tự trước giống hệt với ký tự tiếp theo, toàn bộ bitmask bị buộc phải NaNtừ chối để từ chối (tuân thủ quy tắc số 6)

Các bitmas hợp lệ là những 1bit có chính xác hai lần chuyển tiếp liên tiếp (bit đầu tiên và bit cuối cùng cũng được coi là liên tiếp ):

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

Nói cách khác, đây là những sự kết hợp đó là:

• k? : lớn hơn 0
• !(k%3): đồng dạng với 0 modulo 3
• thấp hơn 15

Các điều kiện khác là:

• !s[5] : không quá 5 ký tự
• s[0]==s[4] : ký tự thứ 1 và thứ 5 giống hệt nhau

Lưu ý : Chúng tôi không kiểm tra rõ ràng k != 15vì bất kỳ từ nào theo mẫu như vậy sẽ bị từ chối bởi điều kiện cuối cùng này.

Các trường hợp thử nghiệm

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

Phiên bản đầu tiên

Đối với bản ghi, phiên bản ban đầu của tôi là 63 byte. Nó vượt qua tất cả các trường hợp thử nghiệm thành công nhưng không phát hiện các ký tự giống hệt nhau liên tiếp.

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

Dưới đây là phiên bản 53 byte được Neil đề xuất trong các nhận xét, hoạt động (và không thành công) tốt như nhau:

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

Chỉnh sửa: Xem câu trả lời của Neil cho phiên bản cố định / hoàn thành của mã trên.

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

Dựa trên mã không chính xác của @ Arnauld, nhưng đã đánh golf và sửa lỗi. Hoạt động bằng cách kiểm tra đầu tiên rằng ký tự đầu tiên giống với ký tự thứ năm (do đó đảm bảo 5 ký tự) và độ dài của chuỗi không quá 5. Sau khi kiểm tra các ký tự trùng lặp liên tiếp, nó vẫn còn để kiểm tra độ chói của chuỗi, cần có một đỉnh và một đáy hai chữ cái cách nhau.

• Nếu đỉnh và đáy là chữ cái giữa và chữ cái đầu / cuối, thì hai phép so sánh đầu tiên và hai phép so sánh cuối cùng sẽ hủy bỏ
• Nếu đỉnh và đáy là hai chữ cái thứ hai và thứ tư, thì hai phép so sánh giữa và hai phép so sánh bên ngoài sẽ hủy bỏ
• Mặt khác, một cái gì đó không thể hủy bỏ và biểu thức tổng thể trả về sai

Chỉnh sửa: Giải pháp thay thế 78 byte dựa trên câu trả lời của @ 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

Mã thoát Python 2, 56 byte

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

Đầu ra thông qua mã thoát: Lỗi cho Sai và chạy thành công cho True.

Đưa chuỗi scó các ký tự abcde, xoay nó thành bcdea, so sánh từng phần tử của các ký tự tương ứng và gán chúng cho năm biến v,w,x,y,z. Độ dài sai cho một lỗi.

Những từ vô cực đều có

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

có thể được kiểm tra chung như v*x+w*y|z == -2. Việc so sánh chuỗi v*x+w*y|z>-2>_ngắn mạch nếu đây là trường hợp, và mặt khác tiếp tục để đánh giá -2>_mà đưa ra một lỗi tên.

Python 2, 110 87 60 byte

Tiết kiệm 1 byte nhờ Neil

Yêu cầu đầu vào kèm theo dấu ngoặc kép, vd 'KNEES'

Truenếu đó là một từ vô cực, Falsenếu không và nó có độ dài 5 và in thông báo lỗi nếu sai độ dài

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

Lấy cảm hứng từ câu trả lời của xnor bằng cách sử dụngmap(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)

giải pháp trước đây:

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)

Sử dụng logic tối ưu hóa của Kevin Cruijssen

PHP, 102 byte

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

Python 2, 71 byte

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

Đưa chuỗi scó các ký tự abcde, xoay nó thành bcdeavà thực hiện so sánh từng phần tử của các ký tự tương ứng.

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)

Kết quả là một danh sách -1, 0, 1. Sau đó, kiểm tra xem kết quả có phải là một trong các chuỗi hợp lệ lên xuống không:

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

như được tạo ra từ mẫu [m,n,-m,-n,0]với m,n=±1. Các 0kiểm tra cuối cùng cho thấy chữ cái đầu tiên và chữ cái cuối cùng bằng nhau và độ dài đảm bảo rằng chuỗi đầu vào có độ dài 5.

Một thay thế 71. Kiểm tra các điều kiện so sánh trong khi đảm bảo độ dài phù hợp.

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 byte

Câu trả lời dựa trên logic của @Jonathan Allan. Nó có thể có thể được chơi golf mặc dù.

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)

Các trường hợp kiểm tra R-fiddle (ví dụ vector hóa nhưng logic tương tự)

GNU Prolog, 47 byte

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

Xác định một vị ngữi thành công (thực tế là vô cùng nhiều lần) cho một từ vô cực, do đó xuất ra "có" khi chạy từ trình thông dịch (như thường thấy đối với Prolog); không thành công cho một từ ứng cử viên có chữ cái đầu tiên và chữ cái cuối không khớp hoặc không dài 5 chữ cái, do đó xuất ra chữ "không" khi chạy từ trình thông dịch; và gặp sự cố với tràn ngăn xếp nếu được cung cấp một từ ứng cử viên không phải là từ vô cực, nhưng đó là năm chữ cái có hai từ đầu tiên và hai từ cuối cùng khớp. (Tôi không chắc tại saoNó bị treo; cuộc gọi đệ quy nên được coi là một tailcall. Rõ ràng trình tối ưu hóa của GNU Prolog không tốt lắm.) Thành công là tương đương với sự thật của Prolog và không tương đương với falsey; một sự cố chắc chắn là khó khăn hơn là sự thật và việc khắc phục nó sẽ khiến giải pháp lâu hơn đáng kể, vì vậy tôi hy vọng điều này được coi là một giải pháp hợp lệ.

Thuật toán khá đơn giản (và thực tế, chương trình này khá dễ đọc); kiểm tra xem các chữ cái có tạo thành một trong bốn mẫu tạo thành một từ vô cực hay không, và nếu không, hãy hoán vị theo chu kỳ và thử lại. Chúng tôi không cần phải kiểm tra một cách rõ ràng cho chữ đôi khi <và >khai thác chúng ta hãy ngầm kiểm tra cùng lúc mà chúng ta kiểm tra xem các vùng đồng bằng phù hợp.

Trên thực tế , 38 27 byte

Câu trả lời này phần lớn lấy cảm hứng từ câu trả lời Jelly tuyệt vời của Jonathan Allan . Có lẽ có một số nơi mà điều này có thể được chơi golf, vì vậy đề nghị chơi golf được chào đón! Hãy thử trực tuyến!

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 byte

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

Hãy thử trực tuyến!

TI-BASIC, 81 byte

Chuỗi để truyền vào chương trình là trong Ans. Trả về (và hiển thị ngầm) 1 nếu từ đã nhập là Infinity Word và 0 (hoặc thoát với thông báo lỗi) nếu không có.

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

Lỗi trên bất kỳ ký tự lặp lại, hoặc các từ không có 5 chữ cái.

05AB1E , 16 byte

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

Cảng @JonathanAllan Jelly câu trả lời 's .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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