(Catatan: Ini adalah spin-off dari tantangan saya sebelumnya Find the Swirling Words! )

Definisi Kata Infinity :

1. Jika Anda terhubung dengan kurva semua karakter Kata Infinity pada alfabet (AZ) Anda mendapatkan simbol infinity ∞ seperti pada diagram di bawah ini.
2. Semua koneksi genap harus turun , semua koneksi aneh harus naik .
3. Anda dapat mengabaikan huruf besar / kecil atau mempertimbangkan / mengonversi semua menjadi huruf besar atau semua ke huruf kecil.
4. Kata-kata input hanya karakter dalam rentang alfabet AZ, tanpa spasi, tanpa tanda baca, atau simbol.
5. Setiap kata harus tepat 5 karakter. Kata> 5 atau <5 tidak valid.
6. Jika sebuah kata memiliki karakter ganda berturut-turut, kata tersebut tidak valid, seperti "FLOOD" atau "QUEEN".
7. Semua Kata Infinity dimulai dan diakhiri dengan karakter yang sama.

Berikut ini beberapa contohnya:

Tugas:

Tulis program atau fungsi lengkap yang akan mengambil kata dari input standar dan akan menampilkan apakah Word Infinity atau bukan. Outputnya bisa benar / salah, 1/0, 1 / Null, dll.

Kasus uji:

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

Aturan:

1. Kode terpendek menang.

Tugas Opsional:

Temukan, sebagai daftar, sebanyak kata Infinity yang Anda bisa dalam kamus bahasa Inggris. Anda dapat mengambil contoh sebagai referensi daftar lengkap kata-kata bahasa Inggris di sini .

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

-7 byte berkat fireflame241 ( 0ị=1ị$-> =ṚḢdan penggunaan IIA⁼2,2untuk menguji 4 rotasi)

-1 Terima kasih kepada Kevin Cruijssen (penggunaan nilad Ø2yang sebelumnya tidak tersedia yang menghasilkan [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
Atau semua test case (ditambah "ATURAN")

Bagaimana?

Kata tak terhingga memiliki:

1. huruf pertama dan terakhir yang sama;
2. panjang 5;
3. tidak ada huruf yang sama di samping satu sama lain;
4. jumlah dari keempat alfabet alfanya sama dengan nol;
5. jumlah dari empat tanda alfabet delta sama dengan nol;
6. dua delta alfabet positif atau dua delta alfabet negatif berturut-turut.

Semua kecuali (1) dan (ekuivalen) (4) dapat direbus ke kondisi bahwa tanda-tanda alfabet delta adalah beberapa rotasi [1,1,-1,-1](di mana tanda 0itu 0)

fireflame241 mencatat bahwa ini kemudian setara dengan delta delta dari tanda-tanda alfabet delta [[2,2],[2,-2],[-2,2],[-2,-2]]yang mungkin diuji dengan nilai absolut yang sama dengan [2,2]!

Bagaimana?

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

Coba di sini.

-38 byte berkat @ dpa97 untuk mengingatkan saya untuk menggunakan char[]bukan String.
-63 byte berkat formula turunan @KarlNapf .
-25 byte dengan mengonversinya dari Java 7 ke Java 8 (dan sekarang mengembalikan boolean bukan integer).

193 byte menjawab:

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

Penjelasan:

• Jika panjang string tidak 5, kami kembali false
• Jika karakter pertama tidak sama dengan karakter terakhir, kami kembali false
• Lalu kami memeriksa empat kasus yang valid satu per satu (mari kita tunjukkan lima karakter sebagai 1 hingga 5), ​​dan kembali truejika sesuai dengan salah satu dari mereka (dan falsesebaliknya):
  1. Jika lima karakter didistribusikan seperti: 1<2<3>4>5(yaitu ALPHA)
  2. Jika lima karakter didistribusikan seperti: 1>2<3<4>5(yaitu EAGLE, HARSH, NINON, PINUP)
  3. Jika lima karakter didistribusikan seperti: 1<2>3>4<5(yaitu RULER)
  4. Jika lima karakter didistribusikan seperti: 1>2>3<4<5(yaitu THEFT, WIDOW)

Keempat aturan ini dapat disederhanakan 1*3<0 and 2*4<0(berkat jawaban Python 2 dari @KarlNapf ).

JavaScript (ES6), 91 89 87 byte

Disimpan 2 byte berkat 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)

Bagaimana itu bekerja

Kami membangun bitmask 4-bit yang kmewakili 4 transisi antara 5 karakter string:

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

• jika karakter sebelumnya lebih tinggi dari yang berikutnya, bit sudah diatur
• jika karakter sebelumnya lebih rendah dari yang berikutnya, bit tidak disetel
• jika karakter sebelumnya identik dengan yang berikutnya, seluruh bitmask dipaksa NaNsehingga kata tersebut ditolak (untuk mematuhi aturan # 6)

Bitmask yang valid adalah yang memiliki tepat dua 1transisi berturut-turut (bit pertama dan terakhir juga dianggap berturut - turut ):

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

Dengan kata lain, ini adalah kombinasi yang:

• k? : lebih besar dari 0
• !(k%3): kongruen dengan 0 modulo 3
• lebih rendah dari 15

Kondisi lainnya adalah:

• !s[5] : tidak ada lebih dari 5 karakter
• s[0]==s[4] : karakter 1 dan 5 identik

NB : Kami tidak secara eksplisit memeriksa k != 15karena kata apa pun yang mengikuti pola seperti itu akan ditolak oleh kondisi terakhir ini.

Uji kasus

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

Versi awal

Sebagai catatan, versi awal saya adalah 63 byte. Ini berhasil melewati semua kasus uji tetapi gagal mendeteksi karakter identik berturut-turut.

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

Di bawah ini adalah versi 53-byte yang disarankan oleh Neil dalam komentar, yang berfungsi dengan baik (dan gagal):

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

Sunting: Lihat jawaban Neil untuk versi kode yang diperbaiki / selesai di atas.

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

Berdasarkan kode yang salah @ Arnauld, tetapi golf dan dikoreksi. Bekerja dengan terlebih dahulu memeriksa bahwa karakter pertama sama dengan yang kelima (sehingga menjamin 5 karakter) dan bahwa panjang string tidak lebih dari 5. Setelah memeriksa karakter duplikat berturut-turut, masih untuk memeriksa keragu-raguan dari string, yang harus memiliki satu puncak dan satu palung terpisah dua huruf.

• Jika puncak dan palung adalah huruf tengah dan pertama / terakhir, maka dua perbandingan pertama dan dua perbandingan terakhir dibatalkan
• Jika puncak dan palung adalah huruf kedua dan keempat, maka dua perbandingan tengah dan dua perbandingan luar dibatalkan
• Jika tidak, sesuatu gagal dibatalkan dan keseluruhan ekspresi mengembalikan false

Sunting: Alternatif solusi 78-byte berdasarkan jawaban @ 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

Kode keluar Python 2, 56 byte

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

Keluaran melalui kode keluar: Kesalahan untuk Salah, dan proses yang berhasil untuk True.

Mengambil string sdengan karakter abcde, memutarnya bcdea, melakukan perbandingan elemen dengan karakter yang sesuai, dan menetapkannya ke lima variabelv,w,x,y,z . Panjang yang salah memberikan kesalahan.

Semua kata-kata tak terbatas

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

yang dapat diperiksa bersama sebagai v*x+w*y|z == -2. Perbandingan v*x+w*y|z>-2>_rangkaian pendek jika ini adalah kasusnya, dan selanjutnya mengevaluasi -2>_yang memberikan kesalahan nama.

Python 2, 110 87 60 byte

Menyimpan 1 byte berkat Neil

Membutuhkan input yang dilampirkan dalam tanda kutip, mis 'KNEES'

Truejika itu kata tak terhingga, Falsejika tidak dan memiliki panjang 5 dan mencetak pesan kesalahan jika panjangnya salah

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

Terinspirasi oleh jawaban xnor menggunakanmap(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)

solusi sebelumnya:

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)

Menggunakan logika yang dioptimalkan dari 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 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]

Mengambil string sdengan karakter abcde, memutarnya bcdea, dan melakukan perbandingan elemen dengan karakter yang sesuai.

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)

Hasilnya adalah daftar -1, 0, 1. Kemudian, periksa apakah hasilnya adalah salah satu urutan naik dan turun yang valid:

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

seperti yang dihasilkan dari template [m,n,-m,-n,0]dengan m,n=±1. 0Cek terakhir bahwa huruf pertama dan terakhir sama, dan panjangnya memastikan bahwa string input memiliki panjang 5.

Alternatif 71. Memeriksa kondisi perbandingan sambil memastikan panjang yang tepat.

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

Jawabannya didasarkan pada logika @Jonathan Allan. Mungkin bisa bermain golf.

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-biola uji kasus (contoh vektor tetapi logika yang sama)

GNU Prolog, 47 byte

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

Menentukan predikat iyang berhasil (berkali-kali tak terhingga, pada kenyataannya) untuk kata tak terhingga, sehingga menghasilkan "ya" ketika dijalankan dari penerjemah (seperti biasa untuk Prolog); gagal untuk kata kandidat yang huruf pertama dan terakhirnya tidak cocok, atau panjangnya 5 huruf, sehingga menghasilkan "tidak" ketika dijalankan dari penerjemah; dan crash dengan stack overflow jika diberi kata kandidat yang bukan kata tak terhingga, tetapi lima huruf dengan dua yang cocok pertama dan terakhir. (Saya tidak yakin mengapaitu crash; panggilan rekursif harus dapat diperlakukan sebagai panggilan ekor. Rupanya pengoptimal GNU Prolog tidak terlalu bagus.) Pengganti adalah padanan Prolog tentang kebenaran, dan gagal dengan padanan falsey; crash jelas lebih bohong daripada benar, dan memperbaikinya akan membuat solusi jauh lebih lama, jadi saya berharap ini dianggap sebagai solusi yang valid.

Algoritma ini cukup sederhana (dan memang, program ini cukup mudah dibaca); periksa apakah huruf-huruf tersebut membentuk salah satu dari empat pola yang menghasilkan kata tak terhingga, dan jika tidak, ubah siklusnya dan coba lagi. Kami tidak perlu secara eksplisit memeriksa huruf ganda sebagai huruf <dan >operator membiarkan kami memeriksa secara implisit bahwa pada saat yang sama kami memeriksa bahwa delta cocok.

Sebenarnya , 38 27 byte

Jawaban ini sebagian besar terinspirasi oleh jawaban Jelly Jonathan Jonathan yang sangat baik . Mungkin ada beberapa tempat di mana ini bisa bermain golf, jadi saran bermain golf menyambut! Cobalah online!

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

Tidak melakukanolf

     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⍳⍞

Cobalah online!

TI-BASIC, 81 byte

String untuk masuk ke program adalah di Ans. Mengembalikan (dan secara implisit menampilkan) 1 jika kata yang dimasukkan adalah Kata Infinity, dan 0 (atau keluar dengan pesan kesalahan) jika tidak.

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

Kesalahan pada karakter berulang, atau kata-kata non-5-huruf.

05AB1E , 16 byte

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

Port of @JonathanAllan jawaban Jelly .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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