रेगेक्स (ECMAScript), 131 बाइट्स
डेडकोड (चैट में) के लिए कम से कम -12 बाइट्स धन्यवाद
(?=((xx+)(?=\2+$)|x+)+)(?=((x*?)(?=\1*$)(?=(\4xx+?)(\5*(?!(xx+)\7+$)\5)?$)(?=((x*)(?=\5\9*$)x)(\8*)$)x*(?=(?=\5$)\1|\5\10)x)+)\10|x
इसे ऑनलाइन आज़माएं!
आउटपुट मैच की लंबाई है।
ECMAScript regexes कुछ भी गिनना बेहद कठिन बनाता है। लूप के बाहर परिभाषित कोई भी बैकएप लूप के दौरान स्थिर रहेगा, लूप के अंदर परिभाषित किसी भी बैकड्रॉप को लूप करते समय रीसेट किया जाएगा। इस प्रकार, लूप पुनरावृत्तियों में राज्य ले जाने का एकमात्र तरीका वर्तमान मैच की स्थिति का उपयोग कर रहा है। यह एक पूर्णांक है, और यह केवल घट सकता है (ठीक है, स्थिति बढ़ जाती है, लेकिन पूंछ की लंबाई कम हो जाती है, और यही हम गणित कर सकते हैं)।
उन प्रतिबंधों को देखते हुए, बस कोप्रेम संख्या गिनना असंभव लगता है। इसके बजाय, हम कुलपति की गणना करने के लिए यूलर के सूत्र का उपयोग करते हैं।
यहाँ यह छद्मकोड में कैसा दिखता है:
N = input
Z = largest prime factor of N
P = 0
do:
P = smallest number > P that’s a prime factor of N
N = N - (N / P)
while P != Z
return N
इस बारे में दो संदिग्ध बातें हैं।
सबसे पहले, हम केवल वर्तमान उत्पाद को इनपुट नहीं बचाते हैं, तो हम इनपुट के प्रमुख कारकों को कैसे प्राप्त कर सकते हैं? चाल यह है कि (एन - (एन / पी)) के समान प्रमुख कारक हैं> पी के रूप में एन। यह नए प्रमुख कारकों को प्राप्त कर सकता है <पी, लेकिन हम वैसे भी अनदेखा करते हैं। ध्यान दें कि यह केवल इसलिए काम करता है क्योंकि हम छोटे से लेकर सबसे बड़े तक के प्रमुख कारकों पर पुनरावृत्ति करते हैं, दूसरे रास्ते पर जाना विफल हो जाएगा।
दूसरा, हमें लूप पुनरावृत्तियों में दो संख्याएँ याद रखनी हैं (P और N, Z की गिनती नहीं है क्योंकि यह निरंतर है), और मैंने सिर्फ इतना कहा कि यह असंभव था! शुक्र है कि हम उन दो नंबरों को एक ही में बदल सकते हैं। ध्यान दें कि, लूप की शुरुआत में, N हमेशा Z का एक गुणक होगा, जबकि P हमेशा Z से कम रहेगा। इस प्रकार, हम सिर्फ N + P को याद रख सकते हैं, और P को मोडुलो के साथ निकाल सकते हैं।
यहाँ थोड़ा और विस्तृत छद्म कोड है:
N = input
Z = largest prime factor of N
do:
P = N % Z
N = N - P
P = smallest number > P that’s a prime factor of N
N = N - (N / P) + P
while P != Z
return N - Z
और यहाँ टिप्पणी regex है:
# \1 = largest prime factor of N
# Computed by repeatedly dividing N by its smallest factor
(?= ( (xx+) (?=\2+$) | x+ )+ )
(?=
# Main loop!
(
# \4 = N % \1, N -= \4
(x*?) (?=\1*$)
# \5 = next prime factor of N
(?= (\4xx+?) (\5* (?!(xx+)\7+$) \5)? $ )
# \8 = N / \5, \9 = \8 - 1, \10 = N - \8
(?= ((x*) (?=\5\9*$) x) (\8*) $ )
x*
(?=
# if \5 = \1, break.
(?=\5$) \1
|
# else, N = (\5 - 1) + (N - B)
\5\10
)
x
)+
) \10
और एक बोनस के रूप में…
रेगेक्स (ECMAScript 2018, मैचों की संख्या), 23 बाइट्स
x(?<!^\1*(?=\1*$)(x+x))
इसे ऑनलाइन आज़माएं!
आउटपुट मैचों की संख्या है। ECMAScript 2018 वेरिएबल-लेंथ लुक-बैक (मूल्यांकित राइट-टू-लेफ्ट) का परिचय देता है, जो इनपुट के साथ सभी संख्याओं को कॉपी करना संभव बनाता है।
यह पता चलता है कि यह स्वतंत्र रूप से लीकी नून के रेटिना समाधान द्वारा उपयोग की जाने वाली विधि है , और रेगेक्स भी समान लंबाई ( और विनिमेय ) है। मैं इसे यहां छोड़ रहा हूं क्योंकि यह रुचि का हो सकता है कि यह विधि ECMAScript 2018 (और न केवल .NET) में काम करती है।
# Implicitly iterate from the input to 0
x # Don’t match 0
(?<! ) # Match iff there is no...
(x+x) # integer >= 2...
(?=\1*$) # that divides the current number...
^\1* # and also divides the input
