Iterated phi क्रम

13

संबंधित: Iterated phi (n) फ़ंक्शन ।

आपकी चुनौती पुनरावृत्त phi फ़ंक्शन की गणना करना है:

f(n) = number of iterations of φ for n to reach 1.

कहां φहै यूलर का फॉन्टेटिव फंक्शन ।

संबंधित OEIS ।

यहाँ इसका ग्राफ दिया गया है:

यहाँ छवि विवरण दर्ज करें

नियम:

आपका लक्ष्य आउटपुट f(n)से n=2है n=100।

यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

यहां उन मानों के बारे में बताया जा सकता है जिन्हें आप जांच सकते हैं:

1, 2, 2, 3, 2, 3, 3, 3, 3, 4, 3, 4, 3, 4, 4, 5, 3, 4, 4, 4, 4, 5, 4, 5, 4, 4, 4, 5, 4, 5, 5, 5, 5, 5, 4, 5, 4, 5, 5, 6, 4, 5, 5, 5, 5, 6, 5, 5, 5, 6, 5, 6, 4, 6, 5, 5, 5, 6, 5, 6, 5, 5, 6, 6, 5, 6, 6, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 5, 6, 7, 5, 7, 5, 6, 6, 7, 5, 6, 6, 6, 6, 6, 6, 7, 5, 6, 6
code-golf  math  sequence  kolmogorov-complexity  number-theory 
— सिंपल ब्यूटीफुल आर्ट
स्रोत
@LuisMendo फिक्स्ड, और इसके खिलाफ जाँच करने के लिए ग्राफ़ + मान भी जोड़े। :-)
— ब्यूटी आर्ट
1
मैंने कोलमोगोरोव-जटिलता टैग में संपादित किया है , क्योंकि यह अनिवार्य रूप से एक निश्चित मूल्य का उत्पादन कर रहा है
— caird coinheringaahing
1
@SimplyBeautifulArt पहले साबित करें कि xऐसे कई मान हैं जो phi(x)एक विशेष निश्चित संख्या है।
— user202729
2
यह एक अच्छी चुनौती है, लेकिन मुझे लगता है कि इसे लागू करने के लिए समाधान के लिए पूछना बेहतर होगा f(n), बजाय इसे निर्धारित संख्याओं के रेंज पर चलाने के। यह कम बाइट्स (आंशिक रूप से गिरगिट चुनौती) के साथ सीमाओं पर कार्यों को लागू करने की क्षमता के साथ भाषाओं के बीच एक अंतर बनाता है
— Uriel
1
: पी क्या आप आसन्न हैं कि मुझे आपको एक फायदा देने के लिए चुनौती को बदलना चाहिए? भले ही इन नियमों को कैसे कहा जाए, कुछ भाषाओं में एक फायदा होगा और कुछ नहीं होगा। @ युरील
— केवल सुंदर कला

जवाबों:

10

हास्केल , 53 52 बाइट्स

1 बाइट बचाने के लिए धन्यवाद निमी!

f<$>[2..100]
f 1=0
f n=1+f(sum[1|1<-gcd n<$>[1..n]])

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

sum[1|1<-gcd n<$>[1..n]]देता है φ(n)( दोष से लिया गया , धन्यवाद!)

fएक पुनरावर्ती कार्य है जो गणना करता है कि 1+φ(n)यदि n नहीं है 1, और 0यदि nहै तो आउटपुट 1, क्योंकि पहुँचने के लिए और अधिक पुनरावृत्तियाँ नहीं हैं1

अंत में प्रत्येक तत्व के लिए लागू f<$>[2..100]की एक सूची बनाता हैf[2..100]

— H.PWiz
स्रोत
7

हास्केल , 70 69 68 बाइट्स

फ़ंक्शन (\n->sum[1|1<-gcd n<$>[1..n]])टोटिएंट फ़ंक्शन है, जिसे हम बार-बार अनाम फ़ंक्शन में लागू करते हैं। धन्यवाद @ बलोनी -1 बाइट के लिए!

संपादित करें: मुझे अभी पता चला है @xnor ने पिछली चुनौती में इस सटीक टोटिएंट फ़ंक्शन का उपयोग किया था ।

length.fst.span(>1).iterate(\n->sum[1|1<-gcd n<$>[1..n]])<$>[2..100]

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

— flawr
स्रोत
1
यह एक टोटका बिल्टिन न होने के लिए बहुत छोटा है!
— लुइस मेन्डो
1
@LuisMendo H.PWiz ने एक समाधान ढूंढा जो और भी छोटा है !
— दोष डिक्री
7

MATL , 16 15 बाइट्स

99:Q"@`_Zptq}x@

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

व्याख्या

99:       % Push [1 2 ... 99]
Q         % Add 1 element-wise: gives [2 3 ... 100]
"         % For each k in that array
  @       %   Push k
  `       %   Do...while
    _Zp   %     Euler's totient function
     tq   %     Duplicate, subtract 1. This is the loop condition
  }       %   Finally (execute on loop exit)
  x       %     Delete
  @       %     Push latest k
          %   End (implicit)
          % End (implicit)
          % Display stack (implicit)

पुराना संस्करण, 16 बाइट्स

99:Qt"t_Zp]v&X<q

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

व्याख्या

99:       % Push [1 2 ... 99]
Q         % Add 1 element-wise: gives [1 2 ... 100]
t"        % Duplicate. For each (i.e. do the following 100 times)
  t       %   Duplicate
  _Zp     %   Euler's totient function, element-wise
]         % End
v         % Concatenate vertically. Gives a 100×100 matrix
&X<       % Row index of the first minimizing entry for each column.
          % The minimum is guaranteed to be 1, because the number of
          % iterations is more than sufficient.
q         % Subtract 1. Display stack (implicit)
— लुइस मेंडो
स्रोत
1
आउटपुट किए गए मान एक से बंद हैं, मुझे लगता है कि इसे ऑनलाइन आज़माएं! सही करता है (लेकिन मैंने पहले कभी MATL का उपयोग नहीं किया है ...)
— caird coinheringaahing
मेरी पोस्ट के अंत की जाँच करें। यह अपेक्षित आउटपुट प्रदान करता है, जिसके लिए आप प्रत्येक पर एक-एक करके उतर जाते हैं।
— बस सुंदर कला
आपके वर्तमान उत्तर द्वारा 2 3 3 4 31 2 2 3 2
— उत्पादित
@cairdcoinheringaahing और SimpleBeautifulArt आह, मैं देखता हूं। धन्यवाद! अब ठीक किया गया
— लुइस मेंडू
6

जेली , 12 11 10 9 बाइट्स

³ḊÆṪÐĿ>1S

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

हाइपर न्यूट्रिनो के लिए -1 बाइट धन्यवाद!

-1 बाइट मिस्टर एक्सकोडर की बदौलत!

-1 बाइट डेनिस की बदौलत

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

³ḊÆṪÐĿ>1S - Main link. No arguments
³         - Yield 100
 Ḋ        - Dequeue. Creates the list [2, 3 ... 99, 100]
    ÐĿ    - For each element, while the results of the next function
          - aren't unique, collect the results...
  ÆṪ      -   Next function: Totient
      >1  - Greater than one?
        S - Sum the columns

जैसा कि यह डेनिस द्वारा बनाया गया था, मुझे (समझ में आता है) यह पता नहीं है कि यह क्यों काम करता है, बस यही करता है।

— केर्ड सिक्काहिरिंग
स्रोत
1
@dylnan सभी तीन उत्तरों से सूची का उत्पादन f(n)होता 2है 100, और प्रश्न इनपुट का उल्लेख नहीं करता है, इसलिए मुझे लगता है कि यह सही संस्करण है
— caird coinheringaahing
@dylnan चुनौती उत्पादन करने के लिए पूछता fके लिए n=2करने के लिए n=100ही नहीं, एक मूल्य।
— ब्यूटी आर्ट
आप सही हैं, मैंने चुनौती की शुरुआत पढ़ी थी और नियम भाग को स्पष्ट रूप से नहीं पढ़ा था
— dylnan
और कोड के संबंध में, क्या #इस मामले में उपयोग करना संभव होगा ? कुछ इस तरह से (जो स्पष्ट रूप से काम नहीं करता है लेकिन किसी ऐसे व्यक्ति द्वारा लिखा गया है जो वाक्यविन्यास को स्पष्ट रूप से समझता है!)
— dylnan
@dylnan संभवतः, लेकिन जैसा कि हम एक निश्चित सूची तैयार कर रहे हैं, प्रत्येक तत्व पर लागू करने के लिए, €आमतौर पर बेहतर है #।
— caird coinheringaahing
6

एपीएल (डायलॉग) , 50 29 25 बाइट्स

देखो 'माँ, कोई निर्मित टोटका!

4 बाइट्स ने @ H.PWiz को धन्यवाद दिया

{⍵=1:0⋄1+∇+/1=⍵∨⍳⍵}¨1+⍳99

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

कैसे?

जाहिरा तौर पर मैं पहले लंबे समय तक (और कठिन) योग्‍य सूत्र के लिए गया था। इतिहास देखें।

⍳⍵- 1कोn

⍵∨ - के साथ gcd n

1= - 1 के बराबर?

+/ - योग 'उन्हें सब

यह कुलदेवता है। बाकी सभी गिनती ( 1+∇) और रेंज पर लागू करने के लिए आवरण है 2..100( ¨1+⍳99)।

— Uriel
स्रोत
4

जे आरईपीएल, 23 ​​बाइट्स

<:#@(5&p:^:a:)"0|2+i.99

मैंने जाँच नहीं की है, लेकिन यह संभवत: नियमित J में काम करता है यदि आप इसे एक संज्ञा के रूप में परिभाषित करते हैं (मैंने इसे REPL पर अपने फोन पर गोल्फ दिया है)।

बिल्ट-इन, यो।

मैं कहूंगा कि कम से कम 2-3 बाइट्स हैं , जो कि a:काम करने के तरीके के कारण बंद हो जाती हैं ( |नो-अप आदि के रूप में उपयोग करने के कारण )।

— गोभी
स्रोत
1
+/*<:5&p:^:a:2+i.99 19 बाइट्स के लिए इसे ऑनलाइन आज़माएं!
— गेलन इवानोव
भविष्य के संदर्भ के लिए, आप "+इसके स्थान पर उपयोग कर सकते हैं "0, इसलिए यह समान रूप से बन सकता है<:#@(5&p:^:a:)"+i.99
— कॉनर ओ'ब्रायन
2
16 बाइट्स+/1<a:5&p:2+i.99
— मील
1
@ मील: क्या आप a:अपने कोड के उपयोग की व्याख्या कर सकते हैं ? इसके बजाय यह कैसे काम करता है ^:?
— गैलन इवानोव
1
@GalenIvanov दूसरी परिभाषा का उपयोग करने के (5&p:)^:a: mरूप में किया जा सकता है जब एक dyad को एक संज्ञा के साथ जोड़ा जाता है और फिर dyadically कहा जाता है। a: 5&p: m&
— मील की दूरी पर
4

जावास्क्रिप्ट (ईएस 6), 115 ... 104 99 बाइट्स

हार्ड-कोडिंग कम हो सकती है, लेकिन आइए एक विशुद्ध गणितीय दृष्टिकोण की कोशिश करें।

f=n=>n>97?6:(P=(n,s=0)=>k--?P(n,s+(C=(a,b)=>b?C(b,a%b):a<2)(n,k)):s>1?1+P(k=s):1)(k=n+2)+' '+f(-~n)

console.log(f())
स्निपेट का विस्तार करें

— Arnauld
स्रोत
हार्ड-कोडिंग 90 बाइट्स ( पास्टेबिन लिंक ) है
— हरमन एल
@ हर्मनलॉइनस्टीन निकाली।
— अरनौलड
3

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

l=0,1
exec"n=len(l);p=2\nwhile n%p:p+=1\nl+=l[p-1]+l[n/p]-n%4%3/2,;print l[n];"*99

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

यह उन टिप्पणियों का उपयोग करता है जो:

  • f(a*b) = f(a) + f(b) - 1, को छोड़कर -1अगर छोड़ दिया गया है aऔर bदोनों भी हैं
  • f(p) = f(p-1) + 1जब pप्राइम होता है, के साथf(2)=1

इनका अर्थ है कि यदि nप्रधान गुणनखंडन है n = 2**a * 3**b * 5**c * 7**d * 11**e * ..., तो f(n) = max(a,1) + b + 2*c + 2*d + 3*e + ..., जहाँ प्रत्येक p>2कारक में योगदान होता है f(p-1)।

मुझे यकीन नहीं है कि अगर ये अतीत को जारी रखते हैं n=100, लेकिन अगर वे करते हैं, तो वे fबिना उपयोग किए परिभाषित करने और गणना करने का एक तरीका देते हैं φ।

— XNOR
स्रोत
2

पॉवरशेल , 110 बाइट्स

$a=,0*101;2..100|%{$i=$_;for($z=$j=0;++$j-lt$i;$z+=$k-eq1){for($k=$j;$j%$k-or$i%$k;$k--){}};($a[$i]=$a[$z]+1)}

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

गणितीय दृष्टिकोण।

वास्तव में, इसके माध्यम से देख रहे हैं, सी उत्तर के समान है , लेकिन स्वतंत्र रूप से विकसित हुआ है। की एक सरणी बनाता 0है, लूप से 2करने के लिए 100है, तो गणना करता है phiका उपयोग करते हुए gcdनिर्माण। दोनों के अंत में पार्न्स में भाग $aअगले गो-राउंड के लिए परिणाम को बचाता है , और पाइप लाइन पर एक प्रति रखता है, जिसके परिणामस्वरूप निहित उत्पादन होता है।

पॉवरशेल, 112 बाइट्स

"122323333434344534444545444545555545455645555655565646555656556656665656565656656757566756666667566"-split'(.)'

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

हार्ड कोडित। उबाऊ। की तुलना में मैं लगभग 10-15 बाइट्स द्वारा गणितीय दृष्टिकोण प्राप्त कर सकता हूं।

— AdmBorkBork
स्रोत
मुझे आश्चर्य है कि क्या आपको वास्तव में एक विभाजक की आवश्यकता है, क्योंकि सभी संख्याएं एकल अंक :)
— त्रुटिपूर्ण हैं
1
क्या आप हमें अपना गणितीय दृष्टिकोण दिखा सकते हैं? यह निश्चित रूप से अधिक दिलचस्प लगता है: P
— कॉनर ओ'ब्रायन
2
@ ConorO'Brien सौभाग्य से, मैं आज सुबह इसे ताजा आँखों से देखने में सक्षम था और हार्ड-कोडेड दृष्टिकोण के नीचे गणितीय दृष्टिकोण को गोल्फ।
— AdmBorkBork
2

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

n=2
exec"print len(bin(n))-3+n%2-~n%9/8-(0x951a5fddc040419d4005<<19>>n&1);n+=1;"*99

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

रूपों को संयुक्त hardcoded लगातार कि के रूप में या तो एक अनुमान को सही के साथ एक अनुमानी अनुमान -0या -1।

— XNOR
स्रोत
2

भूसी , 10 17 बाइट्स

mö←LU¡Sȯṁε⌋ḣtḣ100

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

संपादित करें : +7 बाइट्स वास्तव में उस फ़ंक्शन की मैपिंग कर रहे हैं जिस रेंज के लिए पूछा गया था, इससे पहले कि यह केवल फ़ंक्शन कंप्यूटिंग A003434 था ।

व्याख्या

निम्नलिखित गणना A003434 :

←LU¡S(ṁ(ε⌋))ḣ -- takes a number as input, for example: 39
   ¡          -- iterate the following function on the input: [39,24,8,4,2,1,1,1..]
    S(     )ḣ --   with itself (x) and the range [1..x]..
      ṁ(  )   --   ..map and sum the following
        ε⌋    --     0 if gcd not 1 else 1
  U           -- longest unique prefix: [39,24,8,4,2,1]
 L            -- length: 6
←             -- decrement: 5

वह m(....)ḣ100भाग जो उस सीमा पर कार्य करता है, [२.१००], निश्चित नहीं है कि मैं उस भाग से पहले कैसे चूक गया: एस

— ბიმო
स्रोत
1

PHP, 98 बाइट्स

1,2,<?=join(',',str_split(unpack('H*','##3444E4DEEDEEUUEEVEUVUVVFUVVUfVfVVVVVegWVgVffgV')[1]))?>,6

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

मैंने सभी अंकों को बाइनरी स्ट्रिंग में पैक किया। इसे अनपैक करने के बाद, इसे एक अरै में बदलना और फिर एरे को फिर से मर्ज करना, मुझे केवल 1,2 प्रीपेंड करना था और 6 को अपेंडेंट करना था क्योंकि वे फिट नहीं होते थे या कंट्रोल कोड दिखाई देते थे।

— RFSnake
स्रोत
1

05AB1E , 11 बाइट्स

тL¦ε[DNs#sÕ

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

व्याख्या

тL¦           # push range [2 ... 100]
   ε          # apply to each
    [         # start a loop
     D        # duplicate the current number
      N       # push the loop iteration counter
       s      # swap one copy of the current number to the top of the stack
        #     # if true, break the loop
         s    # swap the second copy of the current number to the top of the stack
          Õ   # calculate eulers totient
— Emigna
स्रोत
1

सी, 112 बाइट्स

a[101];f(i,j,k,t){for(a[i=1]=0;i++<100;printf("%d ",a[i]=a[t]+1))for(t=j=0;++j<i;t+=k==1)for(k=j;j%k||i%k;k--);}

Ungolfed:

a[101];
f(i,j,k,t){
    for(a[1]=0,i=2;i<=100;i++) {   // initialize
        for(t=j=0;++j<i;t+=k==1)   // count gcd(i, j) == 1 (t = phi(i))
            for(k=j;j%k||i%k;k--); // calculate k = gcd(i, j)
        printf("%d ",a[i]=a[t]+1); // print and store results
    }
}

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

— कोलेरा सु
स्रोत
0

एलुमिन , 87 बाइट्स

hhhhhdadtqdhcpkkmzyhqkhwzydqhhwdrdhhhwrysrshhwqdrybpkshehhhwrysrarhcpkksyhaydhehycpkkmr

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

व्याख्या

hhhhhdadt      CONSTANT 100

RANGE FROM 100 to 0
q
  dhc
p

REMOVE 0 AND 1
kk

OVER EACH ELEMENT...
m
  zyh
  q
    kh
    wzyd
    q
      DUPLICATE TOP TWO ELEMENTS...
      hhwdrdhhhwrysrshhw
      GCD...
      qdryb
    p
    ks
    he
    hhhw
    ry
    s
    rarhc
  p
  IS IT ONE? IF SO TERMINATE (FIXPOINT)
  kksyhaydhehyc
p
kk
m
REVERSE THE VALUES
r
— कोनोर ओ ब्रायन
स्रोत
0

पायथ, 38 बाइट्स (प्रतिस्पर्धी नहीं)

.e-+1sl+1kb_jC"Éõ4ÕYHø\\uÊáÛ÷â¿"3

इसे Pyth Herokuapp पर आज़माएं , क्योंकि यह TIO पर किसी भी कारण से काम नहीं करता है।

मुझे कोई संदेह नहीं है कि स्पष्ट पायथ समाधान छोटा है, लेकिन मैं यह देखना चाहता था कि अनुक्रम को संकुचित करके मुझे कितना छोटा कोड मिल सकता है, और मुझे लगता है कि पायथ को सीखना है। यह इस तथ्य का उपयोग करता है कि अनुक्रम का ऊपरी हिस्सा हैlog2(n)+1 ।

व्याख्या

.e-+1sl+1kb_jC"Éõ4ÕYHø\\uÊáÛ÷â¿"3
             C"Éõ4ÕYHø\\uÊáÛ÷â¿"   interpret string as base 256 integer
            j                   3  convert to array of base 3 digits
           _                       invert sequence (original had leading 0s)
.e                                 map with enumeration (k=index, b=element)
       +1k                                   k+1
     sl                            floor(log(   ))
   +1                                             +1
  -       b                                         -b

मुझे संकुचित स्ट्रिंग मिली Ci_.e+1-sl+1ksb"122323333434344534444545444545555545455645555655565646555656556656665656565656656757566756666667566"3, जो कुछ प्रकार के रूपांतरणों के साथ ऊपर दिए गए कोड के ठीक विपरीत है।

— stellatedHexahedron
स्रोत
1
क्यों नॉनकंपेटिंग?
— बस खूबसूरत कला
@SimplyBeautifulArt का अर्थ वास्तव में औपचारिक अर्थों में गैरकानूनी नहीं था; शीर्षक बनाने के लिए है कि और अधिक स्पष्ट संपादित
— stellatedHexahedron
0

ओम v2 , 41 बाइट्स

“ ‽W3>€þΣÌιZ§Á HgüυH§u·β}Bā€ΣNπáÂUõÚ,3“8B

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

शाब्दिक रूप से पूरी तरह से हार्डकोड किया गया ... मैंने वास्तव में ऊपर के अनुक्रम को लिया, सब कुछ छीन लिया जो एक नंबर नहीं था, इसे आधार 8 के रूप में व्याख्या किया गया, फिर इसे ओम के अंतर्निहित आधार 255 नंबर प्रतिनिधित्व में बदल दिया। यही उद्धरण करते हैं। फिर, कार्यक्रम बस 8 बेस में फिर से बदल जाता है।

— ThePlasmaRailgun
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.