सामान्यीकृत पांचवाँ अनुक्रम

Question

इस फाइव थर्टीहाइट पहेली से अनुकूलित ।

पृष्ठभूमि

निम्नलिखित अनंत अनुक्रम की जांच करें:

3 3 3 2 3 3 3 2 3 3 3 2 3 3 2 3 3 3 2 ...

मान लीजिए कि अनुक्रम 1-अनुक्रमित है। iअनुक्रम में वें नंबर निर्धारित करता है कि कितने 3रों वहाँ से पहले कर रहे हैं iवें 2और किसी भी पिछले निम्नलिखित 2रों। इसलिए जब से अनुक्रम शुरू होता है अनुक्रम शुरू 3होना चाहिए 3 3 3 2और चूंकि 3अनुक्रम की शुरुआत में तीन एस हैं, बाद में 3 3 3 2तीन बार खुद को दोहराना होगा। उसके बाद आप पहुंचते हैं 3 3 2क्योंकि अनुक्रम में चौथा नंबर है 2।

फाइव थर्टीहाइट रिडल, थ्रोट्स टू रेशो की सीमा को ट्वोस (जो मैं यहां खराब नहीं करेगा) की सीमा के लिए पूछता है, लेकिन आप यह भी पूछ सकते हैं कि सूचकांक के बाद संचयी अनुपात क्या है i। उदाहरण के लिए पर अनुपात i=4है 3/1 = 3और कम से i=15यह है 11/4 = 2.75।

चलो सामान्य हो जाओ

संख्याओं को देखते हुए nऔर kहम एक समान अनुक्रम बना सकते हैं जो कि शुरू होता है nऔर ठीक उसी तरह जैसे मूल अनुक्रम में वर्णित संख्या iयह निर्धारित करती है कि वें nसे पहले कितने एस दिखाते हैं और किसी भी पिछले एस का अनुसरण करते हैं ।ikk

उदाहरण:

n=2, k=5 अनुक्रम देता है 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 देता है 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 देता है 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

चुनौती

एक फ़ंक्शन / प्रोग्राम लिखें और इसके साथ निम्नलिखित करें। इनपुट के रूप में लें:

• एक सकारात्मक पूर्णांक n
• एक nonnegative पूर्णांक k ≠ n
• एक सकारात्मक पूर्णांक i > n

पहले दो इनपुट nऔर kएक अनुक्रम निर्धारित करते हैं जैसा कि ऊपर वर्णित है और iएक सूचकांक है। मैं उदाहरणों में 1-इंडेक्सिंग का उपयोग कर रहा हूं, लेकिन आपको 0- या 1-इंडेक्सिंग का उपयोग करने की स्वतंत्रता है। यदि 0-अनुक्रमित है तो प्रतिबंध iहै i ≥ n।

तीन नंबर आउटपुट के साथ अनुक्रम में ns से ks के अनुपात में और इंडेक्स पर संख्या सहित i। आउटपुट का प्रारूप या तो सटीक के कम से कम 5 अंकों के साथ दशमलव मान हो सकता है या अनुपात के समान सटीक मान हो सकता है 3524/837या जैसे 3524:837।

दशमलव रूप में, अंतिम अंक आपको पसंद किया जा सकता है। ट्रेलिंग जीरो और व्हॉट्सएप की अनुमति है।

या तो स्ट्रिंग के रूपों में दो संख्याओं को सामान्य करने की आवश्यकता होती है ताकि वे प्रतिरूप हो। उदाहरण के लिए यदि अनुपात 22/4 था, 11/2और 11:2स्वीकार्य हैं , लेकिन 22/4नहीं है।

उदाहरण

n   k   i      output
2   4   15     2.75     or   11/4
6   0   666    5.1101   or   557:109
50  89  64     63       or   63:1
3   2   1000   2.7453   or   733/267
9   12  345    9.4545   or   104/11

यह प्रति भाषा कोड गोल्फ है, इसलिए प्रत्येक भाषा में सबसे छोटा कोड विजेता है।

Comments

सम्बंधित। सम्बंधित।

— मार्टिन एंडर

मैं एक अनुपात के रूप में पूर्णांकों की एक जोड़ी की अनुमति देता हूं, उत्तरदाताओं को संख्याओं को अलग करने की आवश्यकता होती है /या :चुनौती के लिए एक अनावश्यक जटिलता जोड़ता है।

— 10:17

@EriktheOutgolfer को एक दशमलव संख्या की भी अनुमति है

— dylnan

क्या दशमलव आउटपुट के लिए एक मानक फ्लोट पर्याप्त सटीक है?

— मोनिका को फिर से स्थापित करें - notmaynard

@iamnotmaynard मैं फ्लोट प्रारूप के बारे में सख्त नहीं हूँ, इसलिए मुझे ऐसा लगता है

— dylnan

Answer 1

भूसी , 16 बाइट्स

¤/#ωȯ↑⁰J¹`C∞²N¹²

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

परीक्षण के मामलों के रूप में उसी क्रम में इनपुट लेता है। एक परिमेय संख्या को आउटपुट करता है। मुझे ऐसा लगता है कि इसके कई सुपरस्क्रिप्ट हैं, लेकिन मुझे नहीं पता कि इनसे छुटकारा कैसे पाया जाए ...

व्याख्या

¤/#ωȯ↑⁰J¹`C∞²N¹²  Inputs are n, k, i.
             N    Starting with the natural numbers [1,2,3..
   ωȯ             do this until a fixed point is reached:
                    Argument is a list s.
           ∞²       Take the infinite list [n,n,n..
         `C         and split it to the lengths in s.
       J¹           Join the resulting blocks with k.
     ↑⁰             Take the first i elements.
                  Call the result x.
¤             ¹²  For each of n and k,
  #               count their number of occurrences in x
 /                and perform exact division on the results.

Answer 2

पायथन 3 , 94 92 89 87 बाइट्स

def g(n,k,i):o,t=[n],0;exec('o+=[n]*o[t]+[k];t+=1;'*i);return-1-i/(o[1:i+1].count(n)-i)

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

क्रेडिट

• 94 से 92 बाइट्स तक कम: कोलेरा सु ।
• 92 से 89 बाइट्स तक कम: डायलेन ।
• 89 से 87 बाइट्स तक कम: अंडा ।

Comments

यह नहीं होना चाहिए .count(n)?

— कोलेरा सु

@ColeraSu धन्यवाद। पता नहीं कैसे मैंने उसे याद किया, तय किया।

— नील

92 बाइट्स ।

— कोलेरा सु

@ColeraSu धन्यवाद, अद्यतन। मैं निष्पादन का उपयोग शुरू करने की कोशिश करूँगा। यह बहुत मजेदार है।

— नील

89 बाइट्स

— डायलेन

Answer 3

जेली , 22 बाइट्स

³ẋЀ;€⁴Ẏḣ⁵
ẋ`;ÇÐLLƙ`÷/

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

पूरा कार्यक्रम। तर्क लेता है n, k, i।

एक बग है जो अनावश्यक रूप से 1 बाइट से लंबे समय तक रहने की आवश्यकता बनाता है।

Comments

अपनी कुछ ट्रिक्स का इस्तेमाल किया - अच्छा। इस बारे में सोचकर कि बग के लिए सही समाधान क्या होना चाहिए ...

— जोनाथन एलन

@JonathanAllan मुझे क्या लगा यह लाइन है , हालांकि यह सुनिश्चित नहीं है कि `यह काम क्यों करता है। ओह, और जहां आपका जवाब अलग है कि मैं एक गोल्फ को लागू करना भूल गया हूं जिसे मैंने दूसरी भाषा में पाया है _ _>

— आउटगोल्फ़र

Answer 4

जेली ,  25  16 बाइट्स

-9 बाइट्स ~ 50% एग्रीगेलर के जेली उत्तर को समझने के लिए जिम्मेदार है (1. ƙवर्तमान में एक बाइट की लागत वाले बग में एक बग के साथ भी नई-ईश कुंजी का उपयोग करना; 2. वर्तमान अनुक्रम में गिनती और अनुक्रमण से बचने के लिए मैप किए गए पुनरावृत्ति का उपयोग करना; ।) जाओ उसे कुछ श्रेय दो!

³ẋЀj⁴ṁ⁵µÐLLƙ`÷/

एक पूर्ण तीन तर्कों लेने कार्यक्रम: n, k, iपरिणाम प्रिंट है।

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

कैसे?

³ẋЀj⁴ṁ⁵µÐLLƙ`÷/ - Main link
        µ        - monadic chain separation
         ÐL      - apply the monadic chain to the left repeatedly until no change occurs:
³                -   program's 1st argument, n
  Ѐ             -   map across the current sequence (initially just n)
 ẋ               -     repeat (the first run give triangle of n i.e. [[n],[n,n],...,[n]*n]
     ⁴           -     program's 2nd argument, k
    j            -     join
       ⁵         -     program's 3rd argument, i
      ṁ          -     mould like (repeat the list to fill, or cut it, to length i)
            ƙ    - keyed application, map over groups of identical items:
             `   - (this has an arity of 2, make it monadic by repeating the argument)
           L     -   length -> [numberOfNs, numberOfKs]
               / - reduce with:
              ÷  -   division -> [numberOfNs / numberOfKs]
                 - implicit print (a single item list just prints its content)

जानकारी के साथ उदाहरण रन n=2, k=3, i=30:

Start the "loop until no change", ÐL
Note: Initial left argument, n=2, implicitly range-ified by Ѐ to become [1,2]
1. mapped repeat of n: [[2],[2,2]]
          join with k: [2,3,2,2]
         mould like i: [2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3,2,2,2,3]

2. mapped repeat of n: [[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2]]
          join with k: [2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2]
         mould like i: [2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2]
                          ^different to previous result

3. mapped repeat of n: [[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2]]
          join with k: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2]
         mould like i: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2]
                                  ^different to previous result

4. mapped repeat of n: [[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2]]
          join with k: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2]
         mould like i: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2]
                                                      ^different to previous result

5. mapped repeat of n: [[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2],[2,2],[2,2,2],[2,2]]
          join with k: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2]
         mould like i: [2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,2,3,2,2,3,2,2,3,2,2,3,2]
                       all the same as the previous result; stop loop and yield this.

length applied to equal elements: [length([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]), length([3,3,3,3,3,3,3,3,3])]
                                = [21,9]
reduce by division              = [21/9] = [2.3333333333333335]
implicit print                  2.3333333333333335

Answer 5

गणितज्ञ, 85 बाइट्स

(s={#};Do[s=Join[s,#~Table~s[[t]],{#2}],{t,#3}];Last@@Ratios@Tally@s[[#+3;;#3+#+2]])&

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

Answer 6

एपीएल (डायलॉग यूनिकोड) , 126 70 बाइट्स

k n i←⎕
j←⍴v←⍬
:While j<i
v,←k,⍨n⍴⍨{v≢⍬:j⊃v⋄n}j+←1
:End
÷/+/¨n k⍷¨⊂j⍴v

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

खैर, इस उत्तर से 56 बाइट्स को हटाने के लिए @ Adám को धन्यवाद।

यह एक niladic Tradfn (है पारं itional च unctio n ) 1 इनपुट है, जो 3 तत्व सूची है ले रही है।

⎕PP←5को बाइट काउंट में नहीं जोड़ा गया है क्योंकि इसका उपयोग केवल P rint P की मंदी को 5 अंको तक सीमित करने के लिए किया जाता है ।

∇fऔर ∇बाइट की गिनती में नहीं जोड़े गए हैं क्योंकि वे कोड का हिस्सा नहीं हैं, केवल ट्रेडमिल के लिए सीमांकक।

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

k n i←⎕                   ⍝ Take input (←⎕) for k, n and i.
j←⍴v←⍬                    ⍝ Assign (←) an empty vector (⍬) to v, then assign its shape (⍴, which is 0) to j.
:While j<i                ⍝ while j<i, do:
v,←k,⍨n⍴⍨{v≢⍬:j⊃v⋄n}j+←1 ⍝ this:
                     j+←1 ⍝ increment j (+←1)
          {v≢⍬:     }     ⍝ if (:) v does not match (≢) ⍬
               j⊃v        ⍝ return the jth element of v (v[j])
                  ⋄n      ⍝ else (⋄) return n
      n⍴⍨                 ⍝ shape (⍴) n as the result (repeats n result times)
   k,⍨                    ⍝ append (,⍨) k
v,←                       ⍝ append to (,←) v
:End                      ⍝ End while loop
÷/+/¨n k⍷¨⊂j⍴v            ⍝ then:
           j⍴v            ⍝ shape (⍴) v as j (truncates v to j elements)
          ⊂               ⍝ enclose the resulting vector
         ¨                ⍝ for each element
        ⍷                 ⍝ find (returns a boolean vector)
     n k                  ⍝ n and k (⍷ will return a boolean vector for each)
  +/¨                     ⍝ cumulative sum of each vector (returns the number of times n and k appear in v)
÷/                        ⍝ divide them and implicitly return the result.

Answer 7

आर , 88 बाइट्स

function(n,k,i){s=rep(n,n);for(j in 1:i){s=c(s,k,rep(n,s[j]))};z=sum(s[1:i]==n);z/(i-z)}

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

Comments

आप forलूप बॉडी के चारों ओर ब्रेसिज़ से छुटकारा पा सकते हैं क्योंकि केवल एक बयान है।

— ग्यूसेप

Answer 8

स्विफ्ट , 152 बाइट्स

func f(n:Int,k:Int,i:Int){var a=[0];(1...i).map{a+=(0..<(a.count>$0 ?a[$0]:n)).map{_ in n}+[k]};let m=a[1...i].filter{n==$0}.count;print("\(m)/\(i-m)")}

क्या यह जावा से छोटा होगा?

व्याख्या

func f(n:Int,k:Int,i:Int){
  var a=[0]                                    // Initialize the array (the zero is to
                                               //  define the type of the array and will be
                                               //  ignored by the code)
  (1...i).map{                                 // Repeat i times (more than enough):
    a+=(0..<(a.count>$0 ?a[$0]:n)).map{_ in n} //  Add the right amount of n:s to the array
      +[k]                                     //  Add k to the array
  }                                            // End repeat
  let m=a[1...i].filter{n==$0}.count           // Count the amount of n:s in the first
                                               //  i elements of the array
  print("\(m)/\(i-m)")                         // Print the result
}

Answer 9

रूबी , 77 71 70 बाइट्स

->n,k,i{r=[n]
i.times{|c|r+=[n]*r[c]+[k]}
1r*(j=r[1,i].count n)/(i-j)}

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

एक परिमेय लौटाता है, जो दोनों एक संख्या के रूप में कार्य करता है और सटीक रूप से कम किए गए अंश तक स्ट्रिंग करता है।

Answer 10

पायथ , 24 बाइट्स

AEtcH/e.u<sm+*d]QGNH]Q)G

परीक्षण सूट।

[n]सरणी के निश्चित कार्य के तहत निश्चित बिंदु ।

Answer 11

जेफायर , 284 बाइट्स

input n as Integer
input k as Integer
input m as Integer
set s to Array(m)
for i from 1 to n
set s[i]to n
next
set s[i]to k
set N to n
set K to 1
for a from 2 to m
for b from 1 to s[a]
inc i
if i<=m
set s[i]to n
inc N
end if
next
inc i
if i<=m
set s[i]to k
inc K
end if
next
print N/K

तीन अलग-अलग लाइनों पर स्टड से तीन नंबर लेता है। आउटपुट एक सटीक अनुपात जैसे 104/11या 63।

Ungolfed

input n as Integer
input k as Integer
input maxIndex as Integer

set sequence to Array(maxIndex)
for i from 1 to n
    set sequence[i] to n
next
set sequence[i] to k

set nCount to n
set kCount to 1

for a from 2 to maxIndex
    for b from 1 to sequence[a]
        inc i
        if i <= maxIndex
            set sequence[i] to n
            inc nCount
        end if
    next
    inc i
    if i <= maxIndex
        set sequence[i] to k
        inc kCount
    end if
next

print nCount / kCount