Diadaptasi dari teka-teki FiveThirtyEight ini .

Latar Belakang

Periksa urutan tak terbatas berikut:

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

Katakanlah urutannya adalah 1-diindeks. The iJumlah th di urutan menentukan berapa banyak 3s ada sebelum ith 2dan mengikuti setiap sebelumnya 2s. Jadi sejak urutan dimulai dengan 3urutan harus dimulai 3 3 3 2dan karena ada tiga 3s di awal urutan, maka urutan 3 3 3 2harus diulang tiga kali. Setelah itu Anda mencapai 3 3 2karena angka keempat dalam urutan tersebut 2.

Teka-teki FiveThirtyEight meminta batas rasio tiga hingga dua (yang saya tidak akan rusak di sini) tetapi Anda juga dapat bertanya apa rasio kumulatif setelah indeks i. Misalnya rasio at i=4is 3/1 = 3dan at i=15it 11/4 = 2.75.

Mari kita menjadi umum

Angka yang diberikan ndan kkita dapat membuat urutan yang sama yang dimulai dengan ndan seperti urutan asli yang dijelaskan angka di indeks imenentukan berapa banyak yang nmuncul sebelum ith kdan mengikuti yang sebelumnya k.

Contoh:

n=2, k=5 memberi urutan 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 memberi 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 memberi 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

Tantangan

Tulis fungsi / program dan dengan itu lakukan hal berikut. Ambil sebagai masukan:

• bilangan bulat positif n
• bilangan bulat tidak negatif k ≠ n
• bilangan bulat positif i > n

Dua input pertama ndan ktentukan urutan seperti dijelaskan di atas dan imerupakan indeks. Saya menggunakan pengindeksan 1 dalam contoh, tetapi Anda memiliki kebebasan untuk menggunakan pengindeksan 0 atau 1. Jika 0-diindeks maka batasan pada iadalah i ≥ n.

Dengan tiga angka yang dihasilkan, rasio ns ke ks dalam urutan hingga dan termasuk angka pada indeks i. Format output dapat berupa nilai desimal dengan setidaknya 5 digit presisi atau nilai yang tepat sebagai rasio seperti 3524/837atau 3524:837.

Dalam bentuk desimal, digit terakhir dapat dibulatkan sesuka Anda. Nol trailing dan spasi putih diizinkan.

Dalam salah satu bentuk string, kedua angka harus dinormalisasi sehingga keduanya merupakan koprime. Misalnya jika rasionya 22/4, 11/2dan 11:2dapat diterima tetapi 22/4tidak.

Contohnya

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

Ini adalah kode golf per bahasa, jadi kode terpendek dalam setiap bahasa adalah pemenangnya.

Sekam , 16 byte

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

Cobalah online!

Mengambil input dalam urutan yang sama dengan kasus uji. Menghasilkan angka yang rasional. Saya merasa seperti ini memiliki terlalu banyak superskrip, tetapi saya tidak tahu bagaimana cara menyingkirkannya ...

Penjelasan

¤/#ωȯ↑⁰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.

Python 3 , 94 92 89 87 byte

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)

Cobalah online!

Kredit

• Dikurangi dari 94 menjadi 92 byte: Colera Su .
• Dikurangi dari 92 menjadi 89 byte: dylnan .
• Dikurangi dari 89 menjadi 87 byte: ov .

Jelly , 22 byte

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

Cobalah online!

Program lengkap. Mengambil argumen n, k, i.

Ada bug yang membuat ini tidak perlu lebih lama dengan 1 byte.

Jelly ,  25  16 byte

-9 byte ~ 50% disebabkan oleh Erik the Outgolfer's Jelly answer (1. menggunakan kunci new-ish cepat ƙbahkan dengan bug pada penerjemah yang saat ini berharga satu byte; 2. menggunakan pengulangan yang dipetakan untuk menghindari penghitungan dan pengindeksan ke dalam urutan saat ini .) Pergi beri dia kredit!

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

Sebuah program penuh mengambil tiga argumen: n, k, iyang mencetak hasilnya.

Cobalah online!

Bagaimana?

³ẋЀ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)

Misalnya dijalankan dengan input 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

Mathematica, 85 byte

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

Cobalah online!

APL (Dyalog Unicode) , 126 70 byte

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

Cobalah online!

Terima kasih kepada @ Adám karena telah menghapus 56 byte dari jawaban ini.

Ini adalah Tradfn niladic ( trad itional f unctio n ) mengambil 1 input, yang merupakan daftar 3 elemen.

⎕PP←5tidak ditambahkan ke jumlah byte karena itu hanya digunakan untuk membatasi P etak P recision ke 5 digit.

∇fdan ∇tidak ditambahkan ke jumlah byte karena mereka bukan bagian dari kode, hanya pembatas untuk tradfn.

Bagaimana itu bekerja:

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.

R , 88 byte

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)}

Cobalah online!

Cepat , 152 byte

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)")}

Apakah lebih pendek dari Jawa?

Penjelasan

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
}

Ruby , 77 71 70 byte

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

Cobalah online!

Mengembalikan Rasional, yang keduanya beroperasi sebagai angka dan merangkai ke fraksi tereduksi yang tepat.

Pyth , 24 byte

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

Suite uji.

Titik tetap di [n]bawah fungsi array tertentu.

Zephyr , 284 byte

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

Mengambil tiga angka dari stdin pada tiga baris terpisah. Menghasilkan rasio yang tepat seperti 104/11atau 63.

Tidak disatukan

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