(Not: Bu benim önceki meydan okumamın bir sonucudur. Dönen Kelimeleri Bulun! )

Sonsuzluk Kelimesinin Tanımı :

1. Bir Sonsuz Kelimenin tüm karakterlerini alfabedeki (AZ) eğrileriyle bağlarsanız, aşağıdaki diyagramlardaki gibi bir sonsuzluk sembolü ∞ elde edersiniz.
2. Tüm Hatta bağlantısı olmalıdır aşağı tüm tek bağlantıları olmalıdır, yukarı .
3. Büyük / küçük harfleri görmezden gelebilir veya tümünü büyük veya küçük harf olarak düşünebilir / dönüştürebilirsiniz.
4. Giriş sözcükleri yalnızca AZ alfabe aralığındaki, boşluksuz, noktalama işaretleri veya semboller olmayan karakterlerdir.
5. Her kelimenin tam olarak 5 karakterden oluşması gerekir. > 5 veya <5 sözcükleri geçerli değil.
6. Bir kelimenin arka arkaya iki karakterden oluşması durumunda, "FLOOD" veya "QUEEN" gibi kelimeler geçerli değildir.
7. Tüm Infinity Words aynı karakterle başlar ve biter.

İşte bazı örnekler:

Görev:

Standart girişten bir sözcük alacak olan ve Sonsuzluk Kelimesi olup olmadığına dair çıkacak tam bir program veya işlev yazın . Çıktı doğru / yanlış, 1/0, 1 / Null, vb. Olabilir.

Test durumları:

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

Kurallar:

1. En kısa kod kazanır.

İsteğe bağlı Görev:

Listede, İngilizce sözlüğünde olabildiğince çok Sonsuz Kelimeyi bulun . Sen referans olarak örneğin İngilizce kelimelerin tam listesini alabilir burada .

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

Fireflame241 sayesinde -7 bayt ( 0ị=1ị$-> =ṚḢve IIA⁼2,24 dönüşün test edilmesi için kullanımı )

-1 Kevin Cruijssen sayesinde (daha önce mevcut olmayan nilad kullanımı Ø2olan verimleri [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
Veya tüm test durumları (artı "KURALLAR")

Nasıl?

Bir sonsuzluk kelimesi vardır:

1. aynı ilk ve son mektup;
2. uzunluk 5;
3. yan yana eşit harf yok;
4. dört alfabe deltasının sıfıra eşit toplamı;
5. dört alfabe deltasının toplamı sıfıra eşit;
6. iki pozitif alfabe deltası veya üst üste iki negatif alfabe deltası.

(1) ve (eşdeğer) (4) dışındakilerin tümü, alfabe delta işaretlerinin bir dönme hareketi olması koşuluyla kaynatılabilir [1,1,-1,-1](işaretinin olduğu 0yer 0).

fireflame241 bunun daha sonra içinde bulunduğu alfabetik delta işaretlerinin deltasının deltalarına denk olduğunu [[2,2],[2,-2],[-2,2],[-2,-2]], mutlak değerlerin eşittir [2,2]!

Nasıl?

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

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]

Burada dene.

-38 bayt @ dpa97char[] yerine bana kullanmamı hatırlattı String.
-63 bayt @ KarnNapf'ın türetilmiş formülü sayesinde .
-25 bayt Java 7'den Java 8'e dönüştürerek (ve şimdi tamsayı yerine bir boole döndürerek).

193 baytlık cevap:

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

Açıklama:

• Dizenin uzunluğu 5 değilse, geri döneriz. false
• İlk karakter son karaktere eşit değilse, geri döneriz. false
• Ardından dört geçerli durumu birer birer kontrol ediyoruz (en fazla beş karakteri 1 ile 5 olarak gösterelim) trueve bunlardan herhangi birine uygunsa geri dönelim (ve falseaksi takdirde):
  1. Beş karakter şöyle dağıtılıyorsa: 1<2<3>4>5(yani ALPHA)
  2. Beş karakter gibi dağıtılır ise: 1>2<3<4>5(yani EAGLE, HARSH, NINON, PINUP)
  3. Beş karakter şöyle dağıtılıyorsa: 1<2>3>4<5(yani RULER)
  4. Beş karakter gibi dağıtılır ise: 1>2>3<4<5(yani THEFT, WIDOW)

Bu dört kural basitleştirilebilir 1*3<0 and 2*4<0( @KarlNapf'ın Python 2 cevabı sayesinde ).

JavaScript (ES6), 91 89 87 bayt

Ismael Miguel sayesinde 2 bayt kaydedildi

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)

Nasıl çalışır

kDizenin 5 karakteri arasındaki 4 geçişi temsil eden 4 bitlik bir bit maskesi oluştururuz :

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

• önceki karakter bir sonrakinden büyükse, bit ayarlanır
• önceki karakter daha düşükse, sonraki karakter bitse, bit ayarlanmaz
• önceki karakter bir sonrakine özdeş ise, tüm bit maskesi, NaNkelimenin reddedilmesi için zorlanır (kural # 6’ya uymak için)

Geçerli bit maskeleri, arka arkaya tam olarak iki 1geçişe sahip olanlardır (ilk ve son bitler de ardışık olarak kabul edilir ):

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

Başka bir deyişle, bunlar aşağıdaki kombinasyonlardır:

• k? : 0'dan büyük
• !(k%3): 0 modulo 3 ile uyumlu
• 15'ten düşük

Diğer koşullar:

• !s[5] : en fazla 5 karakter
• s[0]==s[4] : 1. ve 5. karakterler aynı

Not : Açıkça kontrol etmiyoruz, k != 15çünkü böyle bir deseni izleyen herhangi bir kelime bu son koşul tarafından reddedilecektir.

Test durumları

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

İlk versiyon

Kayıt için, ilk sürümüm 63 bayttı. Tüm test senaryolarını başarıyla geçiyor ancak ardışık aynı karakterleri bulamıyor.

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

Aşağıda, eşit derecede iyi çalışan (ve başarısız olan) yorumlarda Neil'in önerdiği 53 baytlık bir sürüm bulunmaktadır:

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

Düzenleme: Bkz Neil'in cevabı yukarıdaki kodun sabit / tamamlanmış versiyonu için.

JavaScript (ES6), 78 bayt

([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'un yanlış koduna dayanarak golf oynadı ve düzeltildi. İlk önce ilk karakterin beşinci karakterle aynı olup olmadığını kontrol eder (5 karakteri garanti eder) ve dizenin uzunluğunun 5'den fazla olmadığını kontrol ederek çalışır. bir tepe ve bir tane iki harf ayrılmalıdır.

• Zirve ve oluk orta ve ilk / son harf ise, ilk iki karşılaştırma ve son iki karşılaştırma iptal edilir
• Zirve ve oluk ikinci ve dördüncü harf ise, orta iki karşılaştırma ve dış iki karşılaştırma iptal edilir
• Aksi takdirde, bir şey iptal edilemez ve genel ifade false döndürür

Düzenleme: @ KarlNapf'ın cevabına dayanan alternatif 78-baytlık çözüm:

([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 çıkış kodu, 56 bayt

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

Çıkış kodu ile çıkışlar: Yanlış için Hata ve Gerçek için başarılı çalışma.

sKarakterleri içeren dizgiyi alır abcde, döndürür bcdea, karşılık gelen karakterlerin elementwise karşılaştırmasını yapar ve bunları beş değişkene atar v,w,x,y,z. Yanlış uzunluk bir hata veriyor.

Sonsuz kelimelerin hepsi

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

olarak ortak olarak kontrol edilebilir v*x+w*y|z == -2. Bu durumda zincirleme karşılaştırma v*x+w*y|z>-2>_kısa devre yapar ve başka -2>_bir isim hatası veren değerlendirmeyi sürdürür.

Python 2, 110 87 60 bayt

Neil sayesinde 1 byte tasarruf

Örneğin tırnak içine alınmış girdi gerektirir. 'KNEES'

Trueeğer bir sonsuzluk kelimesiyse, Falsedeğilse ve uzunluğu 5 ise ve yanlışsa hata mesajı yazdırır.

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

Kullanarak xnor 'ın cevabı ilhammap(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)

önceki çözüm:

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'in optimize edilmiş mantığını kullanma

PHP, 102 Bayt

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

Python 2, 71 bayt

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

sKarakterleri içeren dizgiyi alır abcde, onu döndürür bcdeave karşılık gelen karakterleri element olarak karşılaştırır.

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)

Sonuç bir listedir -1, 0, 1. Ardından, sonucun yukarı ve aşağı geçerli sıralardan biri olup olmadığını kontrol eder:

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

olarak şablondan üretilen [m,n,-m,-n,0]ile m,n=±1. Sonuncu 0, ilk ve son harfin eşit olduğunu kontrol eder ve uzunluk, giriş dizesinin 5 uzunluğuna sahip olmasını sağlar.

Alternatif bir 71. Doğru uzunluğu sağlarken karşılaştırmalardaki koşulları kontrol eder.

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 bayt

Cevap @ Jonathan Allan'ın mantığına dayanıyor. Muhtemelen olsa golf olabilir.

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-keman test durumları (vectorized örnek ama aynı mantık)

GNU Prolog, 47 bayt

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

iBir sonsuzluk kelimesi için başarılı olan (aslında, pek çok kez) başarılı olan bir öngörmeyi tanımlar , böylece tercümandan çalıştırıldığında (Prolog için olağan olduğu gibi) "evet" ifadesini tanımlar ; ilk ve son harfleri uyuşmayan veya 5 harf uzunluğunda olmayan bir aday kelime için başarısız olur, bu nedenle tercümandan çalıştırıldığında "hayır" yazar; ve sonsuzluk kelimesi olmayan, ancak ilk ve son iki eşleşmeyle birlikte beş harften oluşan bir aday sözcük verildiğinde yığın taşmasıyla çöküyor. ( Neden olduğundan emin değilimçöküyor; özyinelemeli çağrı bir kuyruk çağrısı olarak değerlendirilebilir olmalıdır. Görünüşe göre GNU Prolog'un optimize edicisi çok iyi değil.) Başarılı olmak Prolog'un gerçeğe eşdeğer olması ve falsey'nin eşdeğeri olarak başarısız olması; bir çarpışma kesinlikle gerçeklerden daha yanlıştır ve bunu düzeltmek çözümü büyük ölçüde daha uzun hale getirir, bu yüzden geçerli bir çözüm sayılır.

Algoritma oldukça basittir (ve gerçekten de program oldukça okunaklıdır); Harflerin sonsuzluk kelimesi oluşturan dört örüntüden birini oluşturup oluşturmadığını kontrol edin, eğer değilse döngüsel olarak izin verin ve tekrar deneyin. İkili harfleri açıkça kontrol etmemize gerek yoktur <ve >operatörler deltaların uyuşup uyuşmadığını aynı anda kontrol etmemize izin verir.

Aslında , 38 27 bayt

Bu cevap büyük ölçüde Jonathan Allan'ın mükemmel Jelly cevabından esinlenmiştir . Muhtemelen bunun golf oynayabileceği birkaç yer vardır, bu nedenle golf önerileri hoş geldiniz! Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

TI-BASIC, 81 bayt

Programa iletilecek dize Ans. Girilen sözcük bir Infinity Word ise, döndürür (ve dolaylı olarak görüntüler) 1, değilse 0 (veya bir hata mesajıyla çıkar).

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

Tekrarlanan karakterlerde veya 5 harfli olmayan sözcüklerde yapılan hatalar.

05AB1E , 16 bayt

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

@JonathanAllan'ın Jöle cevabının limanı .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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