नार्सिसिस्टिक लूप की लंबाई
एक narcissistic संख्या एक प्राकृतिक संख्या है जो प्रत्येक अंक की संख्या के सत्ता में ले जाने पर उसके अंकों के योग के बराबर होती है। उदाहरण के लिए \$8208 = 8^4 + 2^4 + 0^4 + 8^4\$, तो मादक है।
हम एक समारोह को परिभाषित करेंगे \$f(x)\$निम्नलिखित के रूप में, एक प्राकृतिक संख्या के लिए \$x = d_1d_2\dots d_n\$, कहाँ \ _$d_i\$एकल अंक है \$0\$से \ _$9\$(इसलिए \ _$x\$है \$n\$ अंक):
$$f(x) = \sum_{i=1}^nd_i^n$$
इस स्थिति में, एक संख्या narcissistic if \$f(x) = x\$।
हालांकि, जब हमने लागू \$f(x)\$एक संख्या में बार-बार, हम पाते हैं कि एक दिलचस्प पैटर्न उभरता है। किसी भी दिए गए \ के लिए$x\$अनुक्रम या तो एक निश्चित बिंदु (यानी एक नशीली संख्या) तक पहुंचता है, या एक निश्चित लूप में प्रवेश करता है जो असीम रूप से दोहराता है। उदाहरण के लिए, तीन पूर्णांकों ले \$x = 104, 127, 370\$:
\ _$x = 104\$: के बार-बार आवेदन \$f(x)\$ निम्नलिखित श्रृंखला की ओर जाता है
$$104, 65, 61, 37, 58, 89, 145, 190, 730, 370, 370, ...$$
इधर, पाश अंत में, एक निश्चित बिंदु तक पहुँच जाता है \$370\$।
\ _$x = 127\$: के बार-बार आवेदन \$f(x)\$ फलस्वरूप होता है
$$127, 352, 160, 217, 352, 160, 217, ...$$
यहाँ, ट्रिपल \$352, 160, 217\$ विज्ञापन infinitum दोहराता है
\ _$x = 370\$: \ _$x\$यहाँ पहले से ही संकीर्णता है, इसलिए श्रृंखला सिर्फ एक अंतहीन धारा होगी \ _$370\$एस
ये उदाहरण दिए गए \ _ के लिए दो संभावित परिणामों का दस्तावेज है$x\$। लंबाई के एक पाश के रूप में एक निश्चित बिंदु के इलाज तक \$1\$, हम अब हाथ में काम पर आते हैं:
एक प्राकृतिक संख्या को देखते हुए \$n > 0\$, आउटपुट लूप की लंबाई है जो बार-बार \ _ के अनुप्रयोग के माध्यम से उत्पन्न होती है$f(n)\$।
उपरोक्त तीन उदाहरण वापस आए \ _$1\$, \ _$3\$और \$1\$क्रमशः। आप सभी यह मान सकते हैं कि \$n\$अंत में एक पाश है, जो कम से कम सभी के लिए मामला प्रतीत होता है में प्रवेश \$n < 10^4\$। अगर कोई मौजूद है \$n\$जिसके लिए यह गलत है, आपका प्रोग्राम Cthulhu को बुलाने के लिए कुछ भी कर सकता है ।
यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है।
बड़ी संख्या में वापसी \ _$1\$। हालांकि, इन दो सरणियों सभी शामिल \$n < 1000\$ जो उनके आउटपुट के साथ नहीं होना चाहिए:
[ 59, 95, 106, 115, 127, 136, 138, 147, 149, 151, 157, 159, 160, 163, 168, 169, 172, 174, 175, 177, 178, 179, 183, 186, 187, 189, 194, 195, 196, 197, 198, 199, 217, 228, 229, 235, 238, 244, 245, 253, 254, 255, 258, 259, 267, 268, 271, 276, 277, 279, 282, 283, 285, 286, 289, 292, 295, 297, 298, 299, 309, 316, 318, 325, 328, 335, 352, 353, 355, 357, 358, 361, 366, 367, 369, 375, 376, 381, 382, 385, 388, 389, 390, 396, 398, 405, 408, 417, 419, 424, 425, 442, 445, 447, 450, 452, 454, 456, 457, 459, 465, 466, 468, 469, 471, 474, 475, 477, 478, 479, 480, 486, 487, 488, 491, 495, 496, 497, 499, 504, 507, 508, 511, 517, 519, 523, 524, 525, 528, 529, 532, 533, 535, 537, 538, 540, 542, 544, 546, 547, 549, 552, 553, 555, 556, 558, 559, 564, 565, 567, 568, 570, 571, 573, 574, 576, 580, 582, 583, 585, 586, 589, 591, 592, 594, 595, 598, 601, 607, 609, 610, 613, 618, 619, 627, 628, 631, 636, 637, 639, 645, 646, 648, 649, 654, 655, 657, 658, 663, 664, 666, 669, 670, 672, 673, 675, 678, 679, 681, 682, 684, 685, 687, 689, 690, 691, 693, 694, 696, 697, 698, 699, 705, 706, 708, 712, 714, 715, 717, 718, 719, 721, 726, 727, 729, 735, 736, 741, 744, 745, 747, 748, 749, 750, 751, 753, 754, 756, 760, 762, 763, 765, 768, 769, 771, 772, 774, 777, 778, 779, 780, 781, 784, 786, 787, 788, 791, 792, 794, 796, 797, 799, 804, 805, 807, 813, 816, 817, 819, 822, 823, 825, 826, 829, 831, 832, 835, 838, 839, 840, 846, 847, 848, 850, 852, 853, 855, 856, 859, 861, 862, 864, 865, 867, 869, 870, 871, 874, 876, 877, 878, 883, 884, 887, 891, 892, 893, 895, 896, 900, 903, 906, 914, 915, 916, 917, 918, 919, 922, 925, 927, 928, 929, 930, 936, 938, 941, 945, 946, 947, 949, 951, 952, 954, 955, 958, 960, 961, 963, 964, 966, 967, 968, 969, 971, 972, 974, 976, 977, 979, 981, 982, 983, 985, 986, 991, 992, 994, 996, 997, 999]
[ 3, 3, 3, 3, 3, 2, 10, 14, 10, 3, 10, 14, 3, 2, 14, 10, 3, 14, 10, 2, 10, 2, 10, 14, 10, 10, 10, 14, 10, 2, 10, 10, 3, 10, 3, 3, 3, 2, 2, 3, 2, 10, 10, 10, 14, 10, 3, 14, 10, 14, 10, 3, 10, 10, 10, 3, 10, 14, 10, 10, 14, 2, 10, 3, 3, 2, 3, 2, 10, 10, 10, 2, 10, 10, 14, 10, 10, 10, 3, 10, 14, 6, 14, 14, 6, 10, 14, 14, 10, 2, 2, 2, 3, 14, 10, 2, 3, 10, 3, 10, 10, 10, 14, 10, 14, 14, 3, 14, 10, 10, 14, 14, 10, 10, 10, 10, 10, 10, 10, 10, 14, 10, 3, 10, 14, 3, 2, 10, 10, 10, 3, 2, 10, 10, 10, 10, 2, 3, 10, 3, 10, 10, 10, 10, 10, 14, 3, 10, 10, 14, 10, 14, 10, 10, 3, 14, 10, 10, 10, 14, 10, 10, 14, 10, 10, 3, 10, 3, 3, 10, 3, 2, 14, 10, 14, 10, 2, 10, 10, 14, 10, 10, 14, 10, 10, 10, 14, 10, 10, 10, 14, 10, 3, 14, 10, 14, 2, 10, 14, 10, 14, 10, 2, 6, 10, 10, 14, 10, 10, 10, 6, 2, 14, 3, 14, 3, 14, 10, 2, 10, 2, 3, 14, 10, 14, 10, 10, 14, 14, 3, 14, 10, 10, 14, 10, 10, 3, 14, 3, 14, 10, 14, 2, 10, 2, 10, 14, 6, 14, 14, 14, 10, 10, 2, 14, 14, 2, 14, 10, 10, 14, 3, 14, 10, 14, 10, 14, 10, 10, 10, 3, 10, 10, 10, 10, 3, 10, 14, 6, 14, 14, 10, 10, 10, 10, 10, 14, 10, 10, 14, 10, 14, 10, 2, 6, 14, 10, 10, 2, 14, 14, 14, 10, 14, 10, 10, 6, 10, 6, 14, 14, 10, 10, 14, 10, 2, 10, 10, 3, 10, 14, 10, 10, 14, 14, 6, 10, 10, 10, 10, 10, 14, 10, 10, 3, 10, 10, 10, 14, 10, 10, 10, 6, 2, 2, 14, 10, 10, 14, 3, 10, 10, 6, 10, 6, 10, 10, 10, 2, 3, 2]
इसके अलावा, इस एक प्रोग्राम है जो एक पूर्णांक लेता है \$n\$और, प्रत्येक पूर्णांक \ के लिए$1 \le i \le n\$उत्पन्न करता है, यह उत्पादन और लूप उत्पन्न होता है।
यह एक सवाल यह है कि उत्पादन कभी से अधिक है के बारे में Math.SE पर खत्म हो गया है \$14\$, और अगर प्रत्येक प्राकृतिक संख्या अंततः एक लूप में जाएगी या नहीं।
जवाब
हास्केल , 85 बाइट्स
l=length
k?x|elem x k=l$x:takeWhile(/=x)k|q<-show x=(x:k)?sum[read[k]^l q|k<-q]
([]?)
इसे ऑनलाइन आज़माएं!
हास्केल के लिए यह निराशाजनक रूप से लंबा है। हमारे यहाँ एक मुख्य कार्य है। यह kउन संख्याओं की सूची पर नज़र रखता है जो हमने पहले से देखी थीं, सामने वाले नए नंबरों को जोड़ते हुए। एक बार जब हम एक संख्या पर पहुंच जाते हैं, xजो हमारी सूची में होती है, तो हम सबसे बड़े उपसर्ग की तुलना में एक से अधिक रिटर्न करते हैं x।
k ? x
| elem x k
=
length (x : takeWhile (/=x) k)
| otherwise
=
(x : k) ? sum [ read [x] ^ length (show x) | k <- show x ]
अजगर 3 , 107 \ _$\cdots\$ 90 84 बाइट्स
बर्न को धन्यवाद दिया अरनौल को !!!
f=lambda n,l=[]:n in l and-~l.index(n)or f(str(sum(int(d)**len(n)for d in n)),[n]+l)
इसे ऑनलाइन आज़माएं!
एक स्ट्रिंग के रूप में इनपुट की अपेक्षा करता है।
जेली , 12 बाइट्स
मुझे आश्चर्य है कि अगर यह केर्ड के उत्तर के समान है (यह शायद नहीं है, क्योंकि यहां नियंत्रण प्रवाह लगभग निश्चित रूप से किसी को भी आसान हो सकता है जो वास्तव में जेली को जानता है , या शायद एक अच्छा दोषरहित संपीड़न उपयोगिता द्वारा भी)। यह गलत भी हो सकता है।
D*L$S
ÇÐLÇƬL
इसे ऑनलाइन आज़माएं!
रकु , 67 65 64 बाइट्स
{{$_-1-.first(:k,.tail)}($_,{sum .comb X**.chars}...{%\{$_}++})}
इसे ऑनलाइन आज़माएं!
$_, { ... } ... { ... }संख्याओं के अनुक्रम को उत्पन्न करता है$_, बाहरी फ़ंक्शन के साथ शुरू होता है। पहला ब्रेसिज़ फ़ंक्शन को संलग्न करता है जो क्रमिक तत्वों को उत्पन्न करता है, और दूसरा ब्रेस उस फ़ंक्शन को घेरता है जो इंगित करता है कि कब रोकना है।sum .comb X** .charsपूर्ववर्ती से अगले नंबर का उत्पादन करता है।combकोई तर्क विभाजन तार / संख्या के साथ विधि उनके पात्रों / अंक में।charsविधि एक स्ट्रिंग / संख्या में पात्रों / अंकों की संख्या देता है। अंकों की सूची कोX**ऑपरेटर द्वारा अंकों की संख्या के साथ क्रॉस-एक्सपेंजेनेट किया जाता है , फिर सारांशित किया जाता है।- अंतिम स्थिति एक अनाम राज्य हैश चर का उपयोग करती है
%, जो अब तक प्रत्येक तत्व को देखे जाने की संख्या को संग्रहीत करता है। जब वर्तमान संख्या दूसरी बार देखी गई हो तो पुनरावृत्ति रुक जाती है। - उस अनुक्रम को एक आंतरिक अनाम फ़ंक्शन में खिलाया जाता है, जिसे तुरंत कहा जाता है। (यह अनुक्रम को एक चर में संग्रहीत करने की तुलना में थोड़ा छोटा है।) बाहरी फ़ंक्शन की तरह, यह आंतरिक फ़ंक्शन
$_चर में अपने तर्क को स्वीकार करता है । .first(:k, .tail):kअनुक्रम के पहले तत्व का इंडेक्स ( क्रिया विशेषण के लिए धन्यवाद ) पाता है, जो अंतिम तत्व के बराबर होता है.tail।$_ - 1 - .first(...)अनुक्रम की लंबाई है, शून्य से एक, एकल दोहराया तत्व का पहला सूचकांक माइनस, अंतिम चक्र की लंबाई दे।
वोल्फ्राम भाषा (गणितज्ञ) , 78 73 बाइट्स
-5 J42161217 को धन्यवाद। उसका जवाब बेहतर है, इसलिए इसे भी देखें।
#[]//.a_@e___/;a!=e:>a~Tr[#^#2&@@RealDigits@a]~e/.a_@e__:>{e}~Position~a&
इसे ऑनलाइन आज़माएं!
भूसी , 12 बाइट्स
LUṠ-U¡λṁ^L¹d
इसे ऑनलाइन आज़माएं!
अनंत सूची से सबसे लंबे अनूठे उपसर्ग को हटाकर, और उस के सबसे लंबे अनूठे उपसर्ग को लेने का एक बेहतर तरीका मिला।
भूसी , 14 बाइट्स
▼mLUmUṫ¡λṁ^L¹d
इसे ऑनलाइन आज़माएं!
मूल रूप से, हम अनंत सूचियों की एक अनंत सूची बनाते हैं ताकि यह पता लगाया जा सके कि किस में आवश्यक चक्र है। फिर हम चक्र की लंबाई लेते हैं।
व्याख्या
▼mLUmUṫ¡λṁ^L¹d
¡λ apply the following to get an infinite list
d take the digits
^L¹ the the power of their length
ṁ sum them
ṫ get the postfixes of the list
mU get the logest unique prefix of each postfix
U get the longest unique prefix of that
mL Map each cycle to it's lenght
▼ take the minimum
सी (जीसीसी) , 202 ... 149 बाइट्स
f(l){long a[16]={},i,k=l,n;for(;i=k;a[n++&15]=k){for(l=0;k;k/=10)l++;for(;i;i/=10)k+=__builtin_powi(i%10,l);for(l=16;l--;)if(a[l]==k)return n-l&15;}}
इसे ऑनलाइन आज़माएं!
व्याख्या की
f(l) {
long a[16] = {}, // Circular buffer of recently seen values
i, // Current value, will be initialized to l,
// l will become number of digits in i,
// and will later be used as a loop counter
k = l, // Will become f(i)
n; // Current index into the circular buffer
for (; i = k; // Loop forever, let i = f(i)
a[n++ & 15] = k) { // Store f(i) in the buffer
for (l = 0; k; k /= 10) // Set length to zero, loop over all digits in k (which is equal to i)
l++; // Increment l for each digit
// k is zero after this loop
for (; i; i /= 10) // Loop over all digits again
k += __builtin_powi(i % 10, l); // Add pow(digit, length) to k
for (l = 16; l--;) // Check all the values in the buffer
if (a[l] == k) // If k matches a value in the buffer
return n - l & 15; // Return the distance between k and the match in the buffer
}
}
वोल्फ्राम भाषा (गणितज्ञ) , 70 59 बाइट्स
Gather@NestList[Tr[#^#2&@@RealDigits@#]&,#,#]~Count~{_,__}&
इसे ऑनलाइन आज़माएं!
-11 बाइट्स @ से
चारकोल , 27 बाइट्स
ＮθＷ¬№υθ«⊞υθ≔ΣＸ↨θχＬθθ»Ｉ⊕⌕⮌υθ
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:
Ｎθ
इनपुट n।
Ｗ¬№υθ«
एक लूप का पता चलने तक दोहराएं।
⊞υθ
पिछला मान सहेजें।
≔ΣＸ↨θχＬθθ
अगले मान की गणना करें।
»Ｉ⊕⌕⮌υθ
लूप में शब्दों की संख्या को आउटपुट करें।
जावास्क्रिप्ट (ईएस 7), 72 बाइट्स
एक स्ट्रिंग के रूप में इनपुट संख्या की अपेक्षा करता है।
n=>(g=i=>i-g[[...n].map(d=>t+=d**n.length,t=0)|t]||g(-~i,g[n=t+'']=i))``
इसे ऑनलाइन आज़माएं!
टिप्पणी की गई
n => ( // n = input number as a string
g = i => // g is a recursive function taking a counter i
i - // subtract from i
g[ // lookup in g:
[...n].map(d => // for each digit d in n:
t += // add to t:
d ** n.length, // d raised to the power of the length of n
t = 0 // starting with t = 0
) | t // end of map(); yield t
] // end of lookup in g
|| // if the above result is NaN,
g( // do a recursive call:
-~i, // pass i + 1
g[n = t + ''] = i // copy t to n, coerced back to a string
// and set this entry to i in g
) // end of recursive call
)`` // initial call to g with i zero'ish
ब्रेकीलॉग , 27 बाइट्स
{tgjlᵗgᵗz^ᵐ+}ᵃ↖N{¬≠&}↔a↰₄bl
इसे ऑनलाइन आज़माएं!
{tgjlᵗgᵗz^ᵐ+}ᵃ↖N{¬≠&}↔a↰₄bl
{ }ᵃ↖N repeat the predicate N times
and accumulate results
tg last result as list [x]
jlᵗgᵗ [x, [len(x)]]
z^ᵐ each digit ^ length
+ sum
{­&} must have duplicates (not all are different)
↔a reverse and take prefixes (shortest first)
↰₄ that must have duplicates
bl length - 1
MATL , 19 बाइट्स
`XIvIFYAtn^syy-]=Pf
इसे ऑनलाइन आज़माएं! या अनुक्रम साजिश से 50करने के लिए 170(इसके बारे में 30 सेकंड लेता है)।
व्याख्या
` % Do...while
XI % Copy into clipboard I. This implicitly takes input the first time
v % Concatenate stack contents vertically. This attaches the newly computed
% term onto the sequence. The first time it does nothing
I % Paste from clipboard I. This pushes the last computed term
FYA % Convert number to vector of decimal digits
tn^s % Duplicate, number of elements, element-wise power, sum. This computes a
% new term to extend the sequence
yy % Duplicate top two elements in the stack: sequence so far and new term
- % Element-wise difference. This is truthy if all values are nonzero
] % End. A new iteration is run if top of the stack is truthy
= % (The stack contains the computed sequence and a new term that has been
% found to appears in that sequence) Element-wise equality comparison
P % Reverse
f % index of true value. Implicitly display
जेली , 11 बाइट्स
D*L$SƊƬ⁺€ṪL
इसे ऑनलाइन आज़माएं!
D Take the decimal digits
* to the power of
L the length of
$ the list of decimal digits
S and sum them.
Ɗ For all that,
Ƭ iterate until a loop is reached collecting all intermediate results,
€ then for each of the collected results
⁺ iterate again starting from there,
Ṫ take the results from the last result,
L and get the length of that.
यदि हम एक अंक सूची के रूप में इनपुट लेते हैं तो यह और भी कम हो सकता है:
जेली , 10 बाइट्स
*LSDƲƬ⁺€ṪL
इसे ऑनलाइन आज़माएं!
जेली , 11 बाइट्स
मुझे पता चला कि मैं असंबंधित स्ट्रिंग के समान था ।
D*L$SƊƬ⁺€ṪL
एक सकारात्मक लिंक जो एक सकारात्मक पूर्णांक प्राप्त करता है, को स्वीकार करने वाला एक मोनडिक लिंक।
इसे ऑनलाइन आज़माएं!
कैसे?
D*L$SƊƬ⁺€ṪL - Link: n
Ƭ - collect while distinct:
Ɗ - last three links as a monad:
D - digits
$ - last two links as a monad:
L - length
* - exponentiate
S - sum
€ - for each:
⁺ - repeat the last link (the collect-while-distinct, above)
Ṫ - tail (this will be a single loop)
L - length
05AB1E , 15 बाइट्स
Δ¤SDgmO©ªÙ}R®k>
इसे ऑनलाइन आज़माएं!
पूर्णांक के साथ एक सिंगलटन सूची के रूप में इनपुट लेता है।
एक अलग दृष्टिकोण जो 16 बाइट्स में आता है:
λSDgmO}ηíεćk}Ù¥н
इसे ऑनलाइन आज़माएं!
टिप्पणी की :
Δ¤SDgmO©ªÙ}R®k> # implicit input: [x]
Δ } # run until the output does not change:
¤ # take the last integer from the list
S # split into digits
D # duplicate
g # take the length of the copy
m # take each digit to the power of the length
O # sum all powers
© # store this value in the register
ª # and append it to the list
Ù # uniquify the list
# the loop only stops if Ù removed the new element,
# which only happens if it was in the list already
R # reverse the (unique) list
® # take the last computed value
k # find the 0-based index in the list
> # and increment it
λSDgmO}ηíεćk}Ù¥н # implicit input: x
λ } # recursively apply the code to the input
# to generate an infinite list
SDgmO # same as above
η # take the prefixes
í # reverse each prefix
ε } # map over the reversed prefixed
ć # extract the first element
k # find its index in the remaining prefix
# this returns -1 if the prefix was unique
# this results in [-1, ..., -1, res-1, res-1, ...]
Ù # uniquify => [-1, res-1]
# while this list is finite, 05ab1e does not know this
¥ # take the differences => [(res-1) - (-1)] = [res]
н # take the first element => res
एपीएल (डीज़िमा / एपीएल) , 30 29 बाइट्स
{1⊃⍸⌽(⊢/=⊢){+/(⊢*≢)10⊤⍵}⍡⍵⊢⍵}
इसे ऑनलाइन आज़माएं!
-1 बाइट का उपयोग करना ⎕IO←0।
चूंकि चक्र की लंबाई कभी नहीं से अधिक है \$n\$, हम एक निश्चित बिंदु खोजने के बजाय n बार लूप कर सकते हैं, फिर चक्र की लंबाई की गणना करें।
व्याख्या
{⊃⍸1↓⌽(⊢/=⊢){+/(⊢*≢)10⊤⍵}⍡⍵⊢⍵}
⊢⍵ input integer n
{ }⍡⍵ apply the following n times, collecting intermediate results:
10⊤⍵ get base 10 digits
(⊢*≢) raise to the power of length
+/ and sum
(⊢/=⊢) bit mask of the locations of the last element
1↓⌽ reverse and remove first 1
⊃⍸ first index of the last element
आइकन , 99 बाइट्स
procedure f(n)
t:=table()
i:=1
until\t[n]do{t[n]:=i
(s:=0)+:=!n^*n&\z
n:=s
i+:=1}
return i-t[n]
end
इसे ऑनलाइन आज़माएं!
लाल , 125 बाइट्स
func[n][m: copy #()i: 1 while[not m/:n][put m n i i: i + 1 s: 0
foreach d k: to""n[s:(-48 + d)**(length? k)+ s]n: s]i - m/:n]
इसे ऑनलाइन आज़माएं!
स्काला, 117 बाइट्स
गेहूं जादूगर के हास्केल उत्तर का पोर्ट ।
def>(n:Any,k:Seq[_]=Nil):Any=if(k toSet n)1+k.indexOf(n)else>(s"$n".map(d=>math.pow(d-48,s"$n".size).toInt).sum,n+:k)
इसे ऑनलाइन आज़माएं!
स्काला, 160 बाइट्स
Stream.iterate(_){n=>s"$n".map(d=>math.pow(d-48,s"$n".size).toInt).sum}.scanLeft(Seq[Int]())(_:+_).flatMap(_.tails).find(l=>l.size>1&&l.head==l.last).get.size-1
इसे ऑनलाइन आज़माएं!
एक हास्यास्पद लंबे समाधान ने इस तथ्य से भी बदतर बना दिया कि स्काला को **पाइथन और अन्य भाषाएं पसंद नहीं हैं , और initsपहले सबसे बड़े इनिट्स लौटाते हैं, इसलिए हमें उपयोग करना होगा scanLeft(Seq[Int]())(_:+_)।
आर , 84 बाइट्स
x=scan();while(!(y=match(x,F,0))){F=c(x,F);x=sum((x%/%10^((z=nchar(x)):0)%%10)^z)};y
इसे ऑनलाइन आज़माएं!
टिप्पणी की:
x=scan(); # get input as x
# F is vector that holds values of f(x) so far
# (initialized by default as zero)
while(!(y=match(x,F,0))){ # if x is present in F, get its matching index as y,
# otherwise set y to zero.
# While !y (x not present in F yet):
F=c(x,F); # prepend F with x
x=sum((x%/%10^((z=nchar(x)):0)%%10)^z) # update x as f(x):
# sum of decimal digits to the power of # digits
};
y # We exit the while loop when F contains x;
# at this point, y gives the index, which is the
# loop length
के (कोना) , 42 बाइट्स
--/&{x=*|x}{x~?x}{x,_+/{x^'#x}10_vs*|x}/,:
इसे ऑनलाइन आज़माएं!
जे , 40 बाइट्स
-5 FrownyFrog द्वारा!
0(i.~~:@|.)(,*/@~:$1#.&(^#)10#.inv{:)^:_
इसे ऑनलाइन आज़माएं!
जे , 45 बाइट्स
[:#.~[:~:&.|.(,1#.&(^#)10#.inv{:)^:(*/@~:)^:_
इसे ऑनलाइन आज़माएं!
…^:_जब तक परिणाम नहीं बदलता है:…^:(*/@~:)यदि सूची में कोई डुप्लिकेट नहीं है:10#.inv{:अंतिम संख्या के अंक…1#.&(^#)उनकी लंबाई से संचालित, अभिव्यक्त,सूची में जोड़ा गया।[:~:&.|.रिवर्स लिस्ट, इसमें होने वाली पहली घटनाओं का एक बिटमैप प्राप्त करें, रिवर्स बैक करें। तो1 2 3 2 3 -> 3 2 3 2 1 -> 1 1 0 0 1 -> 1 0 0 1 1।[:#.~मिश्रित आधार रूपांतरण के साथ अनुगामी 1s की गणना करें।