(ध्यान दें: यह मेरी पिछली चुनौती का एक स्पिन-ऑफ है जो घूमता हुआ शब्द ढूंढें! )

इन्फिनिटी शब्द की परिभाषा :

यदि आप वर्णमाला (AZ) पर एक इन्फिनिटी शब्द के सभी पात्रों को घटता के साथ जोड़ते हैं, तो आप नीचे दिए गए आरेखों में अनंत प्रतीक ∞ प्राप्त करते हैं।
सभी समान कनेक्शन नीचे होने चाहिए , सभी विषम कनेक्शन ऊपर होने चाहिए ।
आप ऊपरी / निचले हिस्से को अनदेखा कर सकते हैं या सभी ऊपरी मामले या सभी निचले मामलों में परिवर्तित / विचार कर सकते हैं।
AZ के वर्णमाला रेंज में इनपुट शब्द केवल वर्ण हैं, कोई रिक्त स्थान, कोई विराम चिह्न या प्रतीक नहीं हैं।
प्रत्येक शब्द ठीक 5 वर्ण का होना चाहिए। शब्द> 5 या <5 मान्य नहीं हैं।
यदि किसी शब्द में लगातार दो अक्षर होते हैं, तो शब्द "FLOOD" या "QUEEN" की तरह मान्य नहीं है।
सभी इन्फिनिटी शब्द एक ही चरित्र के साथ शुरू और समाप्त होते हैं।

यहाँ कुछ उदाहरण हैं:

कार्य:

एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें जो मानक इनपुट से एक शब्द लेगा और एक इन्फिनिटी वर्ड है या नहीं, आउटपुट करेगा । आउटपुट सही / गलत हो सकता है, 1/0, 1 / नल, आदि।

परीक्षण के मामलों:

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

नियम:

सबसे छोटा कोड जीतता है।

वैकल्पिक कार्य:

एक सूची के रूप में, एक अंग्रेजी शब्दकोश में आप कर सकते हैं के रूप में कई इन्फिनिटी शब्द खोजें । आप उदाहरण के लिए अंग्रेजी शब्दों की पूरी सूची यहाँ संदर्भ के लिए ले सकते हैं ।

code-golf string

— मारियो
स्रोत

क्या हम मान सकते हैं कि इनपुट हमेशा 5 की लंबाई का है? आपने नियम 5 को परिभाषित किया है: " प्रत्येक शब्द में ठीक 5 वर्ण होने चाहिए। शब्द> 5 या <5 मान्य नहीं हैं। ", लेकिन कम या 5 से अधिक वर्ण वाले इन्फिनिटी शब्द नहीं ।

— केविन क्रूजसेन

4

बहुत अजीब बात है कि अल्फा उस पैटर्न को बनाता है

— घातक

@KevinCruijssen आपको यह जाँचना चाहिए कि शब्द परिभाषा का सम्मान करता है, मैंने झूठे मामलों को अद्यतन किया।

— मारियो

1

@Arnauld पाँच "ए" खुद को जोड़ता है (या बिल्कुल नहीं चलता है) एक बिंदु बना रहा है, यह अनंत प्रतीक को आकर्षित नहीं करता है, इसलिए मुझे नहीं लगता कि यह एक सकारात्मक मामला है।

— मारियो

3

मैंने वैकल्पिक टास्क से निपटने का फैसला किया है: "एक सूची के रूप में खोजें, जितने इन्फिनिटी शब्द हैं, उतने ही एक अंग्रेजी शब्दकोश में ..." मैंने इस स्रोत और केविन क्रूज़सेन के उत्तर का उपयोग किया , जो कि 278 इन्फिनिटी शब्दों की इस सूची का उत्पादन करता है ।

— थॉमस क्विन केली

19

जेली , 43 41 40 25 24 23 22 21 14 13 बाइट्स

-7 बाइट्स फ़ायरफ़्लेम 241 के लिए धन्यवाद ( 0ị=1ị$-> =ṚḢऔर IIA⁼2,24 घुमावों के लिए परीक्षण का उपयोग )

-1 केविन क्रूज़सेन के लिए धन्यवाद (पहले अनुपलब्ध निलाद की Ø2पैदावार [2,2])

=ṚḢȧOIṠIIA⁼Ø2

TryItOnline
या सभी परीक्षण मामलों (प्लस "नियम")

कैसे?

एक अनन्तता शब्द है:

वही पहला और अंतिम पत्र;
लंबाई 5;
एक-दूसरे के बराबर कोई अक्षर नहीं;
शून्य के बराबर इसके चार वर्णमाला डेल्टाओं का योग;
शून्य के बराबर इसके चार वर्णमाला डेल्टा संकेतों का योग;
एक पंक्ति में दो सकारात्मक वर्णमाला डेल्टा या दो नकारात्मक वर्णमाला डेल्टा।

सभी लेकिन (1) और (समतुल्य रूप से) (4) को एक ऐसी स्थिति में उबाला जा सकता है कि वर्णमाला डेल्टा संकेत कुछ रोटेशन के होते हैं [1,1,-1,-1](जहां संकेत 0है 0)

fireflame241 ने नोट किया कि यह तब वर्णमाला डेल्टा संकेतों के डेल्टा के [[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)

— जोनाथन एलन
स्रोत

यह कैसे काम करता है?

— ओलिवर नी

आने वाला स्पष्टीकरण।

— जोनाथन एलन

2

@PascalvKooten यह ज्यादातर मज़े के लिए है, और कोड गोल्फ में प्रतिस्पर्धी होने के लिए - मैं कोड गोल्फ और जेली दोनों के लिए काफी नया हूं, इसलिए जेली कार्यक्रम को एक साथ रखना लगभग हर बार एक छोटी पहेली की तरह है; मुझे यह संतोषजनक लगता है। यदि कोई इस खेल से कुछ मूर्त रूप प्राप्त करना चाहता है, तो उसे इसका उपयोग किसी ऐसी भाषा में अपने कौशल को सुधारने के लिए करना चाहिए, जो वास्तविक दुनिया में अधिक सामान्यतः उपयोग की जाती है, या, निश्चित रूप से, किसी की स्वयं की गोल्फ भाषा बनाएं!

— जोनाथन एलन

1

@ lois6b :)। आप ट्यूटोरियल से शुरू करते हैं , और फिर एटम परिभाषा , क्विक परिभाषा के साथ पृष्ठों का उपयोग करते हैं , और स्रोत कोड ब्राउज़ करते हैं ।

— जोनाथन एलन

1

14 बाइट्स यहां का मुख्य गोल्फ II1,1, -1, -1 के रोटेशन के लिए समानता की जांच करने के लिए उपयोग करता है।

— फायरफ्लेम 241

11

जावा 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 के व्युत्पन्न सूत्र के लिए धन्यवाद ।
-25 बाइट्स इसे जावा 7 से जावा 8 में परिवर्तित करके (और अब पूर्णांक के बजाय एक बूलियन लौटाता है)।

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 के पायथन 2 उत्तर के लिए धन्यवाद )।

— केविन क्रूज़सेन
स्रोत

2

+1 अस्पष्टीकृत डाउनवोट की भरपाई करने के लिए ... जहां तक मैं बता सकता हूं, यह एक पूरी तरह से कार्यात्मक समाधान है।

— अरनुलद

1

मैंने इसे 215 को परिवर्तित करके एक चार [] चार [] c = s.toCharArray (); int z = c [1] -c [0], y = c [2] -c [1]; ..

— dpa97

@ dpa97 रिमाइंडर के char[]बजाय इनपुट के रूप में उपयोग करने के लिए धन्यवाद String। -38 बाइट्स थैंक यू।

— केविन क्रूज़सेन

1

आपके बूलियन्स को अनुकूलित किया जा सकता है: z,xऔर w,yउसके पास एक वैकल्पिक संकेत होना चाहिए, इसलिए यह जाँचने के लिए पर्याप्त है z*x<0औरw*y<0

— कार्ल नेफ़

@KarlNapf आह, मैंने कुछ घंटे पहले आपकी टिप्पणी की गलत व्याख्या की। मैंने आपके व्युत्पन्न फ़ॉर्मूला को -63 बाइट्स के लिए लागू किया है। :) धन्यवाद।

— केविन क्रूज़सेन

4

जावास्क्रिप्ट (ईएस 6), 91 89 87 बाइट्स

सेव्ड 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)

यह काम किस प्रकार करता है

हम kस्ट्रिंग के 5 वर्णों के बीच 4 संक्रमणों का प्रतिनिधित्व करते हुए एक 4-बिट बिटमास्क का निर्माण करते हैं:

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

यदि पिछला वर्ण अगले एक से अधिक है, तो बिट सेट है
यदि पिछला वर्ण कम है तो अगला वाला, बिट सेट नहीं है
यदि पिछला चरित्र अगले एक के समान है, तो पूरे बिटमास्क को मजबूर कर दिया जाता है NaNताकि यह शब्द अस्वीकार कर दिया जाए (# 1 का अनुपालन करने के लिए)

मान्य बिटमैक्स वे होते हैं जिनमें लगातार दो 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] : पहली और 5 वीं अक्षर समान हैं

NB : हम स्पष्ट रूप से जाँच नहीं करते हैं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)

नीचे टिप्पणियों में नील द्वारा सुझाया गया 53-बाइट संस्करण है, जो समान रूप से काम करता है (और विफल रहता है):

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

संपादित करें: उपरोक्त कोड के निश्चित / पूर्ण संस्करण के लिए नील का उत्तर देखें ।

— Arnauld
स्रोत

00000 मोडुलो 3 के लिए भी बधाई है, लेकिन फिर से आपके पास पहले और आखिरी अक्षर समान नहीं हो सकते हैं, इसलिए, 15 की तरह, आपको इसके लिए स्पष्ट रूप से परीक्षण करने की आवश्यकता नहीं है।

— नील

उस प्रारंभिक संस्करण के लिए, क्या आप उपयोग कर सकते हैं !((a>b)-(b>c)+(c>d)-(d>e))?

— नील

p<c?0:NaNके रूप में लिखा जा सकता है 0/(p<c), जो 2 बाइट्स बचाता है।

— इस्माईल मिगुएल

@ नील 0 के खिलाफ परीक्षण के बारे में: आप पूरी तरह से सही हैं। (हालांकि, मुझे k?संभावित के कारण परीक्षण की आवश्यकता है NaN।) आपके वैकल्पिक संस्करण के बारे में: जो वास्तव में काम करना चाहिए।

— अरनौलड

@IsmaelMiguel - अच्छी कॉल! धन्यवाद।

— अरनौलड

4

जावास्क्रिप्ट (ईएस 6), 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))

@ अरनुल्द के गलत कोड के आधार पर, लेकिन गोल्फ और सही। पहले जाँच के द्वारा काम करता है कि पहला वर्ण पाँचवाँ है (इस प्रकार 5 वर्णों की गारंटी) और स्ट्रिंग की लंबाई 5 से अधिक नहीं है। लगातार डुप्लिकेट वर्णों की जाँच करने के बाद, यह स्ट्रिंग की लहर की जाँच करने के लिए रहता है, जिसमें एक चोटी और एक कुंड दो अक्षरों के अलग होना चाहिए।

यदि शिखर और गर्त मध्य और पहले / अंतिम अक्षर हैं, तो पहले दो तुलना और अंतिम दो तुलनाएं रद्द हो जाती हैं
यदि शिखर और गर्त दूसरे और चौथे अक्षर हैं, तो मध्य दो तुलनाएं और बाहरी दो तुलनाएं रद्द हो जाती हैं
अन्यथा, कुछ रद्द करने में विफल रहता है और समग्र अभिव्यक्ति झूठी हो जाती है

संपादित करें: @ 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

— नील
स्रोत

3

पायथन 2 निकास कोड, 56 बाइट्स

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

निकास कोड के माध्यम से आउटपुट: गलत के लिए त्रुटि, और ट्रू के लिए सफल रन।

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>_है कि नाम त्रुटि क्या है।

— XNOR
स्रोत

आह, यह अच्छा है कि आपने सशर्त को और अधिक कैसे गोल्फ दिया!

— कार्ल नेफ

3

अजगर 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)

केविन क्रूज़सेन के अनुकूलित तर्क का उपयोग करना

— कार्ल नेफ
स्रोत

क्यों नहीं a*c+b*d+2==0==e?

— नील

@ हाँ क्यों नहीं, लेकिन xnor a*c+b*d|eभी कम है।

— कार्ल नैप

मुझे लगता है कि <-1दोनों -2|1और -2|-1बराबर के बाद से काम कर सकते हैं -1।

— नील

2

PHP, 102 बाइट्स

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

— जार्ग हुल्सरमन
स्रोत

2

पायथन 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

— XNOR
स्रोत

1

आर, 144 बाइट्स

उत्तर @ जोनाथन एलन के तर्क पर आधारित है। यह शायद गोल्फ हो सकता है।

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)

आर-फिडेल परीक्षण के मामले (वेक्टरीकृत उदाहरण लेकिन एक ही तर्क)

— Billywob
स्रोत

आप पहले से ही एक जांच है के बाद से है कि length(s)==5, आप बदल सकते हैं s[1]==tail(s,1)के साथ s[1]==s[5]। लंबाई की जाँच करने के लिए एक बाइट कम विधि है is.na(s[6])। एक साथ इन दो परिवर्तन लौटने TRUEके लिए sलंबाई 5 वास्तव में और की FALSE, अन्यथा रूप में TRUE&NAहै NAलेकिन FALSE&NAहै FALSE। तुम भी बदल कर कुछ बाइट्स बचा सकता है !sum(sign(d))&any(rle(sign(d))$l>1)के साथ !sum(a<-sign(d))&any(rle(a)$l>1)।

— rturnbull

1

जीएनयू प्रोलॉग, 47 बाइट्स

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

एक विधेय को परिभाषित करता है iजो एक अनन्तता के लिए (वास्तव में कई बार, वास्तव में) सफल होता है, इस प्रकार दुभाषिया से चलने पर "हाँ" का उत्पादन होता है (जैसा कि प्रोलॉग के लिए सामान्य है); एक ऐसे उम्मीदवार शब्द के लिए विफल रहता है जिसका पहला और अंतिम अक्षर मेल नहीं खाते हैं, या 5 अक्षर लंबे नहीं हैं, इस प्रकार दुभाषिया से चलने पर "नहीं" का आउटपुट देता है; और एक स्टैक ओवरफ्लो के साथ दुर्घटनाग्रस्त हो जाता है अगर एक उम्मीदवार शब्द दिया जाता है जो एक अनंत शब्द नहीं है, लेकिन जो पहले और आखिरी दो मिलान के साथ पांच अक्षर है। (मुझे यकीन नहीं है कि क्योंयह दुर्घटनाग्रस्त हो जाता है; पुनरावर्ती कॉल को टेलकॉल के रूप में इलाज योग्य होना चाहिए। जाहिरा तौर पर ग्नू प्रोलॉग का ऑप्टिमाइज़र बहुत अच्छा नहीं है।) सफल होना प्रोलॉग की सच्चाई के बराबर है, और फाल्सी के बराबर असफल है; एक दुर्घटना निश्चित रूप से सत्य से अधिक गलत है, और इसे ठीक करने से समाधान काफी लंबा हो जाएगा, इसलिए मुझे उम्मीद है कि यह एक वैध समाधान के रूप में गिना जाता है।

एल्गोरिथ्म काफी सरल है (और वास्तव में, कार्यक्रम काफी पठनीय है); जाँच करें कि क्या पत्र चार पैटर्न में से एक बनाते हैं जो एक अनन्तता शब्द बनाते हैं, और यदि नहीं, तो चक्रीय रूप से अनुमति दें और पुनः प्रयास करें। हमें स्पष्ट रूप से दोहरे अक्षरों की जांच करने की आवश्यकता नहीं है क्योंकि ऑपरेटर <और >ऑपरेटर हमें स्पष्ट रूप से जाँचते हैं कि उसी समय हम जाँचते हैं कि डेल्टास मैच है।

1

दरअसल , 38 27 बाइट्स

यह जवाब काफी हद तक जोनाथन एलन के उत्कृष्ट जेली उत्तर से प्रेरित था । वहाँ शायद कई स्थानों पर जहाँ यह गोल्फ हो सकता है, तो गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

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.

— Sherlock9
स्रोत

1

एपीएल (डायलॉग) , 16 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

1

टीआई-बेसिक, 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-अक्षर-शब्द पर त्रुटियाँ।

— जोशिया विंसलो
स्रोत

1

05AB1E , 16 बाइट्स

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

पोर्ट ऑफ @ जोनाथनअलन के जेली जवाब ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

अनंत शब्द खोजो!

इन्फिनिटी शब्द की परिभाषा :

कार्य:

नियम:

वैकल्पिक कार्य:

जेली , 43 41 40 25 24 23 22 21 14 13 बाइट्स

कैसे?

कैसे?

जावा 8, 231 193 185 122 103 78 बाइट्स

जावास्क्रिप्ट (ईएस 6), 91 89 87 बाइट्स

यह काम किस प्रकार करता है

परीक्षण के मामलों

प्रारंभिक संस्करण

जावास्क्रिप्ट (ईएस 6), 78 बाइट्स

पायथन 2 निकास कोड, 56 बाइट्स

अजगर 2, 110 87 60 बाइट्स

PHP, 102 बाइट्स

पायथन 2, 71 बाइट्स

आर, 144 बाइट्स

जीएनयू प्रोलॉग, 47 बाइट्स

दरअसल , 38 27 बाइट्स

एपीएल (डायलॉग) , 16 15 बाइट्स

टीआई-बेसिक, 81 बाइट्स

05AB1E , 16 बाइट्स