Adapté de cette énigme FiveThirtyEight .

Contexte

Examinez la séquence infinie suivante:

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

Disons que la séquence est indexée sur 1. Le inombre th dans la séquence détermine combien 3il y a de s avant le ith 2et après tout 2s précédent . Donc, puisque la séquence commence par un, 3la séquence doit commencer 3 3 3 2et comme il y a trois 3s au début de la séquence, la sous-séquence 3 3 3 2doit se répéter trois fois. Après cela, vous atteignez 3 3 2parce que le quatrième numéro de la séquence est 2.

L'énigme FiveThirtyEight demande la limite des rapports de trois à deux (que je ne gâcherai pas ici) mais vous pouvez également demander quel est le rapport cumulatif après l'index i. Par exemple, le rapport à i=4is 3/1 = 3et at i=15it est 11/4 = 2.75.

Soyons général

Étant donné les nombres net knous pouvons faire une séquence similaire qui commence par net tout comme la séquence d'origine décrite, le nombre à l'index idétermine combien de ns apparaissent avant le ith ket après tout ks précédent .

Exemples:

n=2, k=5 donne la séquence 2 2 5 2 2 5 2 2 2 2 2 5 2 2 5 ...

n=3, k=0 donne 3 3 3 0 3 3 3 0 3 3 3 0 0 3 3 3 0 ...

n=1, k=3 donne 1 3 1 1 1 3 1 3 1 3 1 3 1 1 1 3 1 ...

Le défi

Écrivez une fonction / un programme et procédez comme suit. Prenez comme entrée:

• un entier positif n
• un entier non négatif k ≠ n
• un entier positif i > n

Les deux premières entrées net kdéterminer une séquence telle que décrite ci - dessus et iest un index. J'utilise l'indexation 1 dans les exemples, mais vous avez la liberté d'utiliser l'indexation 0 ou 1. Si indexé 0, la restriction sur iest i ≥ n.

Avec les trois nombres sortent le rapport de ns à ks dans la séquence jusqu'à et y compris le nombre à l'index i. Le format de la sortie peut être soit une valeur décimale avec au moins 5 chiffres de précision, soit une valeur exacte sous la forme d'un rapport comme 3524/837ou 3524:837.

Sous forme décimale, le dernier chiffre peut être arrondi comme vous le souhaitez. Les zéros de fin et les espaces sont autorisés.

Dans l'une ou l'autre des formes de chaîne, les deux nombres doivent être normalisés afin qu'ils soient coprimes. Par exemple, si le rapport était de 22/4, 11/2et 11:2sont acceptables mais 22/4ne le sont pas.

Exemples

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

C'est le code golf par langue, donc le code le plus court dans chaque langue est le gagnant.

Husk , 16 octets

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

Essayez-le en ligne!

Prend les entrées dans le même ordre que les cas de test. Produit un nombre rationnel. J'ai l'impression que cela a trop d'exposants, mais je ne sais pas comment m'en débarrasser ...

Explication

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

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)

Essayez-le en ligne!

Crédits

• Réduit de 94 à 92 octets: Colera Su .
• Réduit de 92 à 89 octets: dylnan .
• Réduit de 89 à 87 octets: ovs .

Gelée , 22 octets

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

Essayez-le en ligne!

Programme complet. Prend des arguments n, k, i.

Il y a un bogue qui rend ce besoin inutilement plus long d'un octet.

Gelée ,  25  16 octets

-9 octets ~ 50% attribuables à la réponse Erik the Outgolfer's Jelly (1. en utilisant la clé new-ish rapidement ƙmême avec un bogue dans l'interpréteur qui coûte actuellement un octet; 2. en utilisant une répétition mappée pour éviter de compter et d'indexer dans la séquence actuelle .) Allez lui donner du crédit!

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

Un programme complet prenant trois arguments: n , k, iqui imprime le résultat.

Essayez-le en ligne!

Comment?

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

avec des entrées par exemple l' exécution 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 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 126 70 octets

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

Essayez-le en ligne!

Eh bien, merci à @ Adám d'avoir effacé 56 octets de cette réponse.

Ceci est un niladic Tradfn ( trad itional f unctio n ) prenant une entrée, qui est une liste d'éléments 3.

⎕PP←5n'est pas ajouté au nombre d'octets , car il est utilisé pour limiter le P Rint P recision à 5 chiffres.

∇fet ∇ne sont pas ajoutés au nombre d'octets car ils ne font pas partie du code, seulement des délimiteurs pour le tradfn.

Comment ça fonctionne:

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 octets

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

Essayez-le en ligne!

Swift , 152 octets

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

Sera-t-il plus court que Java?

Explication

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
}

Rubis , 77 71 70 octets

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

Essayez-le en ligne!

Renvoie un rationnel, qui fonctionne à la fois comme un nombre et se stringifie à la fraction réduite exacte.

Pyth , 24 octets

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

Suite de tests.

Point fixe de [n]sous certaine fonction de tableau.

Zephyr , 284 octets

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

Prend les trois nombres de stdin sur trois lignes distinctes. Génère un rapport exact tel que 104/11ou 63.

Non golfé

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