Bu FiveThirtyEight bilmecesinden uyarlandı .

Arka fon

Aşağıdaki sonsuz diziyi inceleyin:

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

Diyelim ki dizi 1 dizinli. iSırayla inci sayısı ne kadar belirler 3önce vardır s ith 2ve önceki aşağıdaki 2s. Bu nedenle, sekans bir ile başladığından 3, sekans başlamalı 3 3 3 2ve 3sekansın başında üç s olduğu için, sekansın 3 3 3 2kendini üç kez tekrarlaması gerekir. Bundan sonra 3 3 2, dizideki dördüncü sayı olduğu için ulaşırsınız 2.

FiveThirtyEight bilmecesi üçlülerin ikiye oranını (burada şımartmayacağım) sınırlandırmasını ister, ancak indeks sonrasında kümülatif oranın ne olduğunu da sorabilirsiniz i. Örneğin en oranı i=4IS 3/1 = 3ve en i=15öyle 11/4 = 2.75.

Genel olalım

Sayılar dikkate alındığında nve kbiz ile başlayan benzer bir diziyi yapabilirsiniz norijinal dizi endeksinde numarası açıklanan ve tıpkı ibirçok şeklini belirler nler önce buraya geldik ith kve önceki tüm aşağıdaki ks.

Örnekler:

n=2, k=5 diziyi verir 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 verir 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 verir 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

Meydan okuma

Bir işlev / program yazın ve onunla aşağıdakileri yapın. Girdi olarak al:

• pozitif bir tam sayı n
• negatif olmayan bir tam sayı k ≠ n
• pozitif bir tam sayı i > n

İlk iki giriş nve kyukarıda tarif edildiği gibi bir dizi tespit ieden bir indekstir. Örneklerde 1-indeksleme kullanıyorum ancak 0- veya 1-indeksleme kullanma özgürlüğüne sahipsiniz. 0 dizinli ise, kısıtlama iaçıktır i ≥ n.

Üç sayı çıktısıyla , dizindeki sayıya kadar ve bu sayı da dahil olmak üzere dizideki s / ns oranı . Çıkış biçimi ya da en azından 5 hassas basamağı ya da bu gibi bir oran olarak kesin bir değere sahip bir ondalık değer olabilir veya .ki3524/8373524:837

Ondalık biçimde son rakam istediğiniz gibi yuvarlanabilir. Sondaki sıfırlara ve boşluklara izin verilir.

Dize biçimlerinden herhangi birinde, iki sayının eşleşmesi için normalleştirilmesi gerekir. Örneğin, oran 22/4 ise 11/2ve 11:2kabul edilebilir ancak kabul edilemez 22/4ise.

Örnekler

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

Bu, dil başına kod golfüdür, bu nedenle her dilde en kısa kod kazanır.

Kabuk , 16 bayt

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

Çevrimiçi deneyin!

Girişleri test senaryolarıyla aynı sırada alır. Rasyonel bir sayı verir. Bunun çok fazla altyazısı olduğunu hissediyorum, ancak onlardan nasıl kurtulacağımı bilmiyorum ...

açıklama

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

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)

Çevrimiçi deneyin!

Kredi

• 94'ten 92 bayta düşürüldü : Colera Su .
• 92'den 89 bayta düşürüldü : dylnan .
• 89'dan 87 bayta düşürüldü : ovs .

Jöle , 22 bayt

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

Çevrimiçi deneyin!

Tam program. Argümanları Alır n, k, i.

Bunun gereksiz yere 1 bayt daha uzun olmasını gerektiren bir hata var.

Jöle ,  25  16 bayt

-9 byte ~% 50 atfedilen için Erik Outgolfer en Jelly cevap (1. hızlı yeni ish anahtarı kullanarak ƙbile tercüman bir hata henüz byte maliyet ile; 2. akım dizisi içine önlemek sayma ve endeksleme bir eşleştirilmiş tekrarını kullanarak .) Git ona biraz kredi ver!

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

Üç argüman alarak tam bir programı: n, k, isonuç yazdırılan bulunur.

Çevrimiçi deneyin!

Nasıl?

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

girişli örnek, çalışma 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 bayt

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

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 126 70 bayt

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

Çevrimiçi deneyin!

@ Adám'a bu yanıttan 56 bayt ayırdığı için teşekkürler.

Bu giriş parametresiz Tradfn olan ( Çevirmen itional f unctio n 3 eleman listesi 1 girişi alarak).

⎕PP←5bayt sayısına eklenmez, çünkü yalnızca P pint P gerilemesini 5 basamakla sınırlamak için kullanılır .

∇f ve ∇ bayt sayısına eklenmezler, çünkü kodun bir parçası değildirler, sadece tradfn için sınırlayıcılardır.

Nasıl çalışır:

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 bayt

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

Çevrimiçi deneyin!

Swift , 152 bayt

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

Java'dan daha kısa olacak mı?

açıklama

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
}

Yakut , 77 71 70 bayt

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

Çevrimiçi deneyin!

Hem sayı olarak çalışan hem de tam indirgenmiş kesire dizgi oluşturan bir Rasyonal döndürür.

Pyth , 24 bayt

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

Test odası.

[n]Dizinin belirli bir işlevi altında sabit noktası .

Zephyr , 284 bayt

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

Üç sayıyı stdin'den üç ayrı hatta alır. 104/11Veya gibi tam bir oran çıktısı verir 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