পটভূমি

নিম্নলিখিত অসীম ক্রম পরীক্ষা করুন:

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গুলি করার আগে দেখা iতম kএবং কোন পূর্ববর্তী নিম্নলিখিত kগুলি।

উদাহরণ:

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এটি একটি সূচক index আমি উদাহরণগুলিতে 1-ইনডেক্সিং ব্যবহার করছি তবে আপনার 0- বা 1-ইনডেক্সিং ব্যবহার করার স্বাধীনতা রয়েছে। যদি 0-সূচিযুক্ত হয় তবে সীমাবদ্ধতাi হয়i ≥ n ।

তিন নম্বর আউটপুট অনুপাত সঙ্গে nথেকে গুলি kগুলি ক্রমানুসারে প্রয়োজন এবং সূচিতে নম্বর সহ আপ i। আউটপুটটির ফর্ম্যাটটি হ'ল কমপক্ষে ৫ টি অঙ্কের নির্ভুলতার সাথে দশমিক মান বা এর মতো অনুপাত হিসাবে একটি সঠিক মান হতে পারে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

এটি ভাষা প্রতি কোড গল্ফ, তাই প্রতিটি ভাষার সংক্ষিপ্ততম কোডটি বিজয়ী।

code-golf number sequence

— dylnan
সূত্র

সম্পর্কিত। সম্পর্কিত।

— মার্টিন এন্ডার

আমি অনুপাত হিসাবে একজোড়া পূর্ণসংখ্যার অনুমতি দেওয়ার পরামর্শ দিই, উত্তরদাতাদের চ্যালেঞ্জের সাথে সংখ্যাগুলি আলাদা করার জন্য /বা :অপ্রয়োজনীয় জটিলতা যুক্ত করার প্রয়োজন।

— এরিক আউটগল্ফার

@ এরিকথ আউটগলফার একটি দশমিক সংখ্যাও অনুমোদিত

— dylnan

দশমিক আউটপুট জন্য একটি মান ভাসমান যথেষ্ট সঠিক?

— মনিকা পুনরায় ইনস্টল করুন - notmaynard

@ আইমনোটমায়ার্ড আমি ভাসা ফর্ম্যাট সম্পর্কে কঠোর নই তাই হ্যাঁ আমিও তাই মনে করি

— dylnan

5

হুশ , 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.

— Zgarb
সূত্র

4

পাইথন 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 বাইট: হ্রাস ।

— নিল
সূত্র

এটা করা উচিত নয় .count(n)?

— কলেরা সু

ধন্যবাদ ক্যালেরাসু ধন্যবাদ জানি না আমি কীভাবে মিস করেছি, স্থির।

— নিল

92 বাইট ।

— কোলেরা সু

@ কলেরাশু ধন্যবাদ, আপডেট হয়েছে। আমি এক্সিকিউটিস ব্যবহার শুরু করার চেষ্টা করব। যে বেশ শান্ত.

— নিল

89 বাইট

— ডাইলান

4

জেলি , 22 বাইট

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

এটি অনলাইন চেষ্টা করুন!

পুরো প্রোগ্রাম। লাগে আর্গুমেন্ট n, k,i ।

একটি বাগ রয়েছে যা এটি অকারণে 1 বাইট দ্বারা দীর্ঘ হওয়া প্রয়োজন।

— এরিক দ্য আউটগল্ফার
সূত্র

আপনার কয়েকটি কৌশল ব্যবহার করেছেন - দুর্দান্ত। বাগের জন্য সঠিক সমাধানটি কী হওয়া উচিত তা নিয়ে ভাবছেন ...

— জোনাথন অ্যালান

@ জোনাথান অ্যালান আমাকে যে আঘাত করেছে তা এই লাইন , যদিও নিশ্চিত করা যায় না কেন এটি প্রয়োগ করা কার্যকর হয় `। ওহ, এবং যেখানে আপনার উত্তরটির পার্থক্য রয়েছে তা হ'ল আমি অন্য ভাষাতে পাওয়া গল্ফটি প্রয়োগ করতে ভুলে গিয়েছিলাম> _>

— এরিক দি আউটগলফার

4

জেলি , 25 16 বাইট

-9 বাইটস ~ 50% এরিক আউটগল্ফার জেলি উত্তরটির সাথে দায়ী (১. ƙবর্তমানে বাইট ব্যয়কারী দোভাষীর মধ্যে একটি বাগ থাকলেও নতুন-ইশ কী ব্যবহার করে; ২. গণনা এড়াতে এবং বর্তমান অনুক্রমের সাথে সূচীকরণ করতে ম্যাপযুক্ত পুনরাবৃত্তি ব্যবহার করে) ।) যাও তাকে কিছু ক্রেডিট দাও!

³ẋÐ€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

— জোনাথন অ্যালান
সূত্র

3

গণিত, 85 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— J42161217
সূত্র

2

এপিএল (ডায়ালগ ইউনিকোড) , 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 বাইট অপসারণের জন্য @ অ্যাডমকে ধন্যবাদ।

এই niladic Tradfn (হয় Trad itional চ unctio এন ) 1 ইনপুট, যা একটি 3 উপাদান তালিকা গ্রহণ।

⎕PP←5বাইট গণনা যোগ করা হয় না কারণ এটি শুধুমাত্র সীমিত করতে ব্যবহৃত হচ্ছে পি দ্রণ পি থেকে recision 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.

— জে স্যালা
সূত্র

1

আর , 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)}

এটি অনলাইন চেষ্টা করুন!

— duckmayr
সূত্র

forলুপের দেহের চারপাশে থাকা ধনুর্বন্ধনীগুলি থেকে মুক্তি পেতে পারেন কারণ কেবলমাত্র একটি বিবৃতি রয়েছে।

— জিউসেপ

0

সুইফ্ট , 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
}

— হারমান এল
সূত্র

0

রুবি , 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)}

এটি অনলাইন চেষ্টা করুন!

একটি যৌক্তিক ফিরিয়ে দেয়, যা উভয়ই একটি সংখ্যা হিসাবে পরিচালনা করে এবং হ্রাসিত ভগ্নাংশের সংক্ষিপ্ত রূপ দেয়।

— মনিকা পুনরায় স্থাপন করুন - notmaynard
সূত্র

0

পাইথ , 24 বাইট

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

পরীক্ষা স্যুট.

[n]অ্যারের নির্দিষ্ট ফাংশনের অধীনে নির্দিষ্ট পয়েন্ট ।

— ফুটো নুন
সূত্র

0

Zephyr , 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

— DLosc
সূত্র

জেনারালাইজড ফাইটি থ্রিটি এইট সিউকেন্সস

পটভূমি

চ্যালেঞ্জ

হুশ , 16 বাইট

ব্যাখ্যা

পাইথন 3 , 94 92 89 87 বাইট

ক্রেডিট

জেলি , 22 বাইট

জেলি , 25 16 বাইট

কিভাবে?

গণিত, 85 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 126 70 বাইট

কিভাবে এটা কাজ করে:

আর , 88 বাইট

সুইফ্ট , 152 বাইট

ব্যাখ্যা

রুবি , 77 71 70 বাইট

পাইথ , 24 বাইট

Zephyr , 284 বাইট

Ungolfed