ดัดแปลงมาจากปริศนาห้าสิบสามสิบแปด

พื้นหลัง

ตรวจสอบลำดับอนันต์ต่อไปนี้:

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

สมมติว่ามีการเรียงลำดับดัชนี 1 iจำนวนวันในลำดับกำหนดจำนวน3s มีก่อนiวัน2และต่อไปนี้ก่อน ๆ2s ดังนั้นเมื่อลำดับเริ่มต้นด้วย3ลำดับจะต้องเริ่มต้น3 3 3 2และเนื่องจากมีสาม3s ที่จุดเริ่มต้นของลำดับที่ลำดับ3 3 3 2จะต้องทำซ้ำตัวเองสามครั้ง หลังจากนั้นคุณก็มาถึง3 3 22เนื่องจากจำนวนที่สี่ในลำดับคือ

FiveThirtyEight ปริศนาขอวงเงินอัตราส่วนของสามเพื่อ twos (ซึ่งผมจะไม่เสียนี่) iแต่คุณยังสามารถขอให้สิ่งที่อัตราส่วนสะสมคือหลังจากที่ดัชนี ตัวอย่างเช่นอัตราส่วนที่i=4เป็น3/1 = 3และที่มันเป็นi=1511/4 = 2.75

รับทั่วไป

ตัวเลขที่กำหนดnและkเราสามารถสร้างลำดับที่คล้ายกันซึ่งเริ่มต้นด้วยnและเช่นเดียวกับลำดับเดิมที่อธิบายหมายเลขที่ดัชนีiกำหนดจำนวนns ที่แสดงก่อนith kและถัดจากks ก่อนหน้า

ตัวอย่าง:

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
• จำนวนเต็มที่ไม่ใช่ค่าลบ k ≠ n
• จำนวนเต็มบวก i > n

สองอินพุตแรกnและkกำหนดลำดับตามที่อธิบายไว้ข้างต้นและiเป็นดัชนี ฉันใช้การจัดทำดัชนี 1 ตัวในตัวอย่าง แต่คุณมีอิสระที่จะใช้ 0- หรือ 1 การจัดทำดัชนี ถ้า 0 การจัดทำดัชนีแล้วข้อ จำกัด เกี่ยวกับการมีii ≥ n

กับสามตัวเลขการส่งออกอัตราส่วนของnที่จะอยู่ในลำดับขึ้นไปและรวมถึงหมายเลขที่ดัชนีk iรูปแบบของผลลัพธ์อาจเป็นค่าทศนิยมที่มีความแม่นยำอย่างน้อย 5 หลักหรือค่าที่แน่นอนเป็นอัตราส่วนเช่น3524/837หรือ3524:837หรือ

ในรูปแบบทศนิยมตัวเลขหลักสุดท้ายสามารถปัดเศษได้ตามต้องการ อนุญาตให้มีค่าศูนย์และช่องว่างต่อท้าย

ในรูปแบบของสตริงตัวเลขทั้งสองจำเป็นต้องทำให้เป็นมาตรฐานเพื่อให้เป็น coprime ตัวอย่างเช่นถ้าอัตราส่วนคือ 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

นี่คือรหัสกอล์ฟต่อภาษาดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษาจึงเป็นผู้ชนะ

Husk , 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.

Python 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 ไบต์: Colera ซู
• ลดลงจาก 92 เป็น 89 ไบต์: dylnan
• ลด 89-87 ไบต์: OVS

เยลลี่ , 22 ไบต์

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

ลองออนไลน์!

โปรแกรมเต็มรูปแบบ ใช้อาร์กิวเมนต์n, k,i ,

มีข้อผิดพลาดที่ทำให้ต้องมีความยาวเกิน 1 ไบต์โดยไม่จำเป็น

เยลลี่ ,  25  16 ไบต์

-9 bytes ~ 50% ที่เป็นของErik the Jelly คำตอบของ Outgolfer (1. การใช้ new-ish key อย่างรวดเร็วƙแม้ว่าจะมีข้อผิดพลาดในล่ามในปัจจุบันที่ต้องเสียค่าใช้จ่ายเป็นไบต์ 2. ใช้ repetition ที่แมปเพื่อหลีกเลี่ยงการนับและจัดทำดัชนี .) ไปให้เครดิตเขาหน่อย!

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

Mathematica, 85 ไบต์

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

ลองออนไลน์!

APL (Dyalog Unicode) , 126 70 ไบต์

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

ลองออนไลน์!

ขอบคุณ @ Adámที่กำจัดคำตอบนี้ 56 ไบต์

นี่คือ niladic Tradfn ( ตราด itional ฉ unctio n ) การป้อนข้อมูล 1 ซึ่งเป็นรายการที่ 3 องค์ประกอบ

⎕PP←5จะไม่เพิ่มนับไบต์เพราะมันใช้เพียงเพื่อ จำกัดP rint P recision ไป5หลัก

∇fและ∇ไม่ถูกเพิ่มในการนับไบต์เนื่องจากไม่ได้เป็นส่วนหนึ่งของรหัสเพียงตัวคั่นสำหรับ tradfn

มันทำงานอย่างไร:

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 ไบต์

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

ลองออนไลน์!

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

มันจะสั้นกว่า Java หรือไม่?

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

ส่งคืน Rational ซึ่งทั้งสองทำงานเป็นตัวเลขและทำให้เป็นเศษส่วนที่ลดลงอย่างแน่นอน

Pyth , 24 ไบต์

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

ชุดทดสอบ

จุดคงที่ของ[n]ฟังก์ชั่นบางอย่างของอาเรย์

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

รับตัวเลขสามตัวจาก stdin ในสามบรรทัดแยกกัน ส่งออกอัตราส่วนที่แน่นอนเช่น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