Chuyển thể từ câu đố FiveThentyEight này .

Lý lịch

Kiểm tra trình tự vô hạn sau:

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

Giả sử chuỗi này được lập chỉ mục 1. Số ithứ trong dãy xác định có bao nhiêu 3s trước ith 2và theo sau bất kỳ 2s nào trước đó . Vì vậy, vì chuỗi bắt đầu bằng một 3chuỗi phải bắt đầu 3 3 3 2và vì có ba 3s ở đầu chuỗi nên chuỗi 3 3 3 2phải lặp lại ba lần. Sau đó bạn đạt được 3 3 2vì số thứ tư trong chuỗi là 2.

Câu đố FiveThentyEight yêu cầu giới hạn tỷ lệ từ ba đến hai lần (mà tôi sẽ không làm hỏng ở đây) nhưng bạn cũng có thể hỏi tỷ lệ tích lũy sau chỉ số là bao nhiêu i. Ví dụ tỷ lệ tại i=4là 3/1 = 3và tại i=15đó 11/4 = 2.75.

Chúng ta hãy nói chung

Các số đã cho nvà kchúng ta có thể tạo một chuỗi tương tự bắt đầu bằng nvà giống như chuỗi ban đầu được mô tả số tại chỉ số ixác định có bao nhiêu ns hiển thị trước ith kvà theo sau bất kỳ ks nào trước đó .

Ví dụ:

n=2, k=5 đưa ra trình tự 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 cho 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 cho 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

Các thách thức

Viết một hàm / chương trình và với nó làm như sau. Lấy làm đầu vào:

• một số nguyên dương n
• một số nguyên không âm k ≠ n
• một số nguyên dương i > n

Hai đầu vào đầu tiên nvà kxác định một chuỗi như được mô tả ở trên và ilà một chỉ mục. Tôi đang sử dụng lập chỉ mục 1 trong các ví dụ nhưng bạn có quyền tự do sử dụng lập chỉ mục 0 hoặc 1. Nếu 0-index thì hạn chế ilà i ≥ n.

Với ba số đầu ra, tỷ lệ của ns với ks trong chuỗi lên đến và bao gồm cả số tại chỉ mục i. Định dạng của đầu ra có thể là giá trị thập phân có ít nhất 5 chữ số chính xác hoặc giá trị chính xác theo tỷ lệ như 3524/837hoặc 3524:837.

Ở dạng thập phân, chữ số cuối cùng có thể được làm tròn theo cách bạn muốn. Số 0 và khoảng trắng được phép.

Trong một trong hai dạng chuỗi, hai số cần được chuẩn hóa để chúng là nguyên tố cùng nhau. Ví dụ: nếu tỷ lệ là 22/4, 11/2và 11:2được chấp nhận nhưng 22/4không được.

Ví dụ

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

Đây là mã golf cho mỗi ngôn ngữ, vì vậy mã ngắn nhất trong mỗi ngôn ngữ là người chiến thắng.

Husk , 16 byte

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

Hãy thử trực tuyến!

Đưa đầu vào theo thứ tự giống như các trường hợp thử nghiệm. Xuất ra một số hữu tỷ. Tôi cảm thấy như thế này có quá nhiều bản sao, nhưng tôi không biết làm cách nào để loại bỏ chúng ...

Giải trình

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

Hãy thử trực tuyến!

Tín dụng

• Giảm từ 94 xuống 92 byte: Colera Su .
• Giảm từ 92 xuống 89 byte: dylnan .
• Giảm từ 89 xuống 87 byte: ovs .

Thạch , 22 byte

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

Hãy thử trực tuyến!

Chương trình đầy đủ. Lấy đối số n, k, i.

Có một lỗi khiến cho điều này cần phải dài hơn 1 byte một cách không cần thiết.

Thạch ,  25  16 byte

-9 byte ~ 50% được quy cho câu trả lời Jelly của Outgolfer (1. sử dụng khóa mới-ish nhanh chóng ƙngay cả với một lỗi trong trình thông dịch hiện đang tốn một byte; 2. sử dụng sự lặp lại được ánh xạ để tránh đếm và lập chỉ mục vào chuỗi hiện tại .) Đi cho anh ta một số tín dụng!

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

Một chương trình đầy đủ dùng ba đối số: n, k, itrong đó in kết quả.

Hãy thử trực tuyến!

Làm sao?

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

Ví dụ chạy với đầu vào 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

Toán học, 85 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Vâng, cảm ơn @ Adám đã xóa sạch 56 byte trong câu trả lời này.

Đây là một Tradfn niladic ( trad itional f unctio n ) lấy 1 đầu vào, mà là một danh sách 3 yếu tố.

⎕PP←5không được thêm vào số byte bởi vì nó chỉ được sử dụng để giới hạn số lần truy cập P rint P xuống còn 5 chữ số.

∇fvà ∇không được thêm vào số byte bởi vì chúng không phải là một phần của mã, chỉ là các dấu phân cách cho tradfn.

Làm thế nào nó hoạt động:

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

Hãy thử trực tuyến!

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

Nó sẽ ngắn hơn Java?

Giải trình

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

Hãy thử trực tuyến!

Trả về một Rational, cả hai đều hoạt động như một số và sắp xếp theo phân số chính xác.

Bình thường , 24 byte

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

Bộ thử nghiệm.

Điểm cố định [n]dưới chức năng nhất định của mảng.

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

Lấy ba số từ stdin trên ba dòng riêng biệt. Xuất ra một tỷ lệ chính xác như 104/11hoặc 63.

Bị đánh cắp

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