Adattato da questo indovinello FiveThirtyEight .

sfondo

Esamina la seguente sequenza infinita:

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

Diciamo che la sequenza è 1-indicizzata. Il inumero th nella sequenza determina quanti 3s ci sono prima del ith 2e dopo quelli precedenti 2. Quindi, poiché la sequenza inizia con una 3sequenza, deve iniziare 3 3 3 2e poiché ci sono tre 3secondi all'inizio della sequenza, la sottosequenza 3 3 3 2deve ripetersi tre volte. Dopodiché raggiungi 3 3 2perché è il quarto numero nella sequenza 2.

L'enigma FiveThirtyEight chiede il limite dei rapporti da tre a due (che non rovinerò qui) ma puoi anche chiedere quale sia il rapporto cumulativo dopo l'indice i. Ad esempio, il rapporto at i=4è 3/1 = 3e è i=15esso 11/4 = 2.75.

Andiamo in generale

Dati numeri ne kpossiamo fare una sequenza simile che inizia con ne proprio come la sequenza originale descritta, il numero all'indice idetermina quanti ns appaiono prima del ith ke dopo quelli precedenti k.

Esempi:

n=2, k=5 dà la sequenza 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 dà 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 dà 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

La sfida

Scrivi una funzione / programma e con esso procedi come segue. Prendi come input:

• un numero intero positivo n
• un numero intero non negativo k ≠ n
• un numero intero positivo i > n

I primi due input ne kdeterminano una sequenza come descritto sopra ed iè un indice. Sto usando l'indicizzazione 1 negli esempi ma hai la libertà di usare l'indicizzazione 0 o 1. Se 0-indicizzato, la limitazione iè i ≥ n.

Con i tre numeri emette il rapporto da ns a ks nella sequenza fino al numero dell'indice compreso i. Il formato dell'output può essere un valore decimale con almeno 5 cifre di precisione o un valore esatto come rapporto come 3524/837o 3524:837.

In forma decimale, l'ultima cifra può essere arrotondata come preferisci. Sono consentiti zeri finali e spazi bianchi.

In entrambe le forme di stringa i due numeri devono essere normalizzati in modo che siano coprimi. Ad esempio se il rapporto era 22/4 11/2e 11:2sono accettabili ma 22/4non lo sono.

Esempi

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

Questo è il golf del codice per lingua, quindi il codice più corto in ogni lingua è il vincitore.

Buccia , 16 byte

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

Provalo online!

Accetta input nello stesso ordine dei casi di test. Emette un numero razionale. Sento che questo ha troppi apici, ma non so come liberarmene ...

Spiegazione

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

Provalo online!

Titoli di coda

• Ridotto da 94 a 92 byte: Colera Su .
• Ridotto da 92 a 89 byte: dylnan .
• Ridotto da 89 a 87 byte: ovs .

Gelatina , 22 byte

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

Provalo online!

Programma completo. Prende argomenti n, k, i.

C'è un bug che rende questa necessità inutilmente più lunga di 1 byte.

Gelatina ,  25  16 byte

-9 byte ~ 50% attribuibile alla risposta Jelly di Erik the Outgolfer (1. utilizzo della chiave new-ish veloce ƙanche con un bug nell'interprete che attualmente costa un byte; 2. utilizzo di una ripetizione mappata per evitare il conteggio e l'indicizzazione nella sequenza corrente .) Vai a dargli un po 'di credito!

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

Un programma completo di prendere tre argomenti: n, k, iche stampa il risultato.

Provalo online!

Come?

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

Esempio fuga con ingressi 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]])&

Provalo 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

Provalo online!

Bene, grazie a @ Adám per aver cancellato 56 byte da questa risposta.

Questo è un Tradfn niladic ( trad pre- sentano f unctio n ) prendendo 1 ingresso, che è una lista 3 elemento.

⎕PP←5non viene aggiunto al conteggio di byte poiché viene utilizzato solo per limitare la P tampa P recision a 5 cifre.

∇fe ∇non vengono aggiunti al conteggio dei byte perché non fanno parte del codice, ma solo delimitatori per il tradfn.

Come funziona:

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

Provalo online!

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

Sarà più corto di Java?

Spiegazione

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
}

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

Provalo online!

Restituisce una Razionale, che opera sia come numero che si stringe alla frazione ridotta esatta.

Pyth , 24 byte

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

Suite di test.

Punto fisso [n]sotto determinate funzioni dell'array.

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

Prende i tre numeri dallo stdin su tre linee separate. Emette un rapporto esatto come104/11 o 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